﻿using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Xml.Schema;
using System.Collections.Generic;

namespace CompletionDataTest
{
    [TestClass]
    public class MSBuildXmlSchemaTest
    {
        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void GetDescendantElementTestMethod1()
        {
            CompletionData.MSBuildXmlSchema.GetDescendantElement(null, new XmlSchemaElement(), new string[1]);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void GetDescendantElementTestMethod2()
        {
            CompletionData.MSBuildXmlSchema.GetDescendantElement(new XmlSchema(), null, new string[1]);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void GetDescendantElementTestMethod3()
        {
            CompletionData.MSBuildXmlSchema.GetDescendantElement(new XmlSchema(), new XmlSchemaElement(), null);
        }

        [TestMethod]
        public void GetDescendantElementTestMethod4()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[]{"hoge"});
            Assert.AreEqual(0, result.Count);
        }

        [TestMethod]
        public void GetDescendantElementTestMethod5()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = new XmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "hoge" });
            Assert.AreEqual(0, result.Count);
        }

        [TestMethod]
        public void GetDescendantElementTestMethod6()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = new XmlSchema();
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "hoge" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod7()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project" });
            Assert.AreEqual(9, result.Count);
            Assert.AreEqual("Choose", result[0].Name);
            Assert.AreEqual("Import", result[1].Name);
            Assert.AreEqual("ImportGroup", result[2].Name);
            Assert.AreEqual("ItemDefinitionGroup", result[3].Name);
            Assert.AreEqual("ItemGroup", result[4].Name);
            Assert.AreEqual("ProjectExtensions", result[5].Name, true);
            Assert.AreEqual("PropertyGroup", result[6].Name, true);
            Assert.AreEqual("Target", result[7].Name, true);
            Assert.AreEqual("UsingTask", result[8].Name, true);
        }

        #region /Project/Choose
        /// <summary>
        /// /Project/hoge
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod8()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "hoge" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/Choose
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod9()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("Otherwise", result[0].Name);
            Assert.AreEqual("When", result[1].Name);
        }

        /// <summary>
        /// /Project/Choose/hoge
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod10()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose" ,"hoge"});
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/Choose/Otherwise
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod11()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose", "Otherwise" });
            Assert.AreEqual(3, result.Count);
            Assert.AreEqual("Choose", result[0].Name);
            Assert.AreEqual("ItemGroup", result[1].Name);
            Assert.AreEqual("PropertyGroup", result[2].Name);
        }

        /// <summary>
        /// /Project/Choose/Otherwise/hoge
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod12()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose", "Otherwise","hoge" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/Choose/Otherwise/Choose
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod13()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose", "Otherwise", "Choose" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("Otherwise", result[0].Name);
            Assert.AreEqual("When", result[1].Name);
        }

        /// <summary>
        /// /Project/Choose/Otherwise/ItemGroup
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod14()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose", "Otherwise", "ItemGroup" });
            Assert.AreEqual(44, result.Count);
            Assert.AreEqual("ApplicationDefinition", result[0].Name);
            Assert.AreEqual("AppxManifest", result[1].Name);
            Assert.AreEqual("AppxManifestFileNameQuery", result[2].Name);
            Assert.AreEqual("AppxReservedFileName", result[3].Name);
            Assert.AreEqual("AppxSystemBinary", result[4].Name);
            Assert.AreEqual("BaseApplicationManifest", result[5].Name);
            Assert.AreEqual("BootstrapperFile", result[6].Name);
            Assert.AreEqual("Bscmake", result[7].Name);
            Assert.AreEqual("ClCompile", result[8].Name);
            Assert.AreEqual("ClInclude", result[9].Name);
            Assert.AreEqual("CodeAnalysisDependentAssemblyPaths", result[10].Name);
            Assert.AreEqual("CodeAnalysisDictionary", result[11].Name);
            Assert.AreEqual("CodeAnalysisImport", result[12].Name);
            Assert.AreEqual("COMFileReference", result[13].Name);
            Assert.AreEqual("Compile", result[14].Name);
            Assert.AreEqual("COMReference", result[15].Name);
            Assert.AreEqual("Content", result[16].Name);
            Assert.AreEqual("CustomBuildStep", result[17].Name);
            Assert.AreEqual("EmbeddedResource", result[18].Name);
            Assert.AreEqual("FileAssociation", result[19].Name);
            Assert.AreEqual("Folder", result[20].Name);
            Assert.AreEqual("Import", result[21].Name);
            Assert.AreEqual("Link", result[22].Name);
            Assert.AreEqual("Manifest", result[23].Name);
            Assert.AreEqual("Midl", result[24].Name);
            Assert.AreEqual("NativeReference", result[25].Name);
            Assert.AreEqual("None", result[26].Name);
            Assert.AreEqual("Page", result[27].Name);
            Assert.AreEqual("PostBuildEvent", result[28].Name);
            Assert.AreEqual("PreBuildEvent", result[29].Name);
            Assert.AreEqual("PreLinkEvent", result[30].Name);
            Assert.AreEqual("PRIResource", result[31].Name);
            Assert.AreEqual("ProjectCapability", result[32].Name);
            Assert.AreEqual("ProjectConfiguration", result[33].Name);
            Assert.AreEqual("ProjectReference", result[34].Name);
            Assert.AreEqual("PublishFile", result[35].Name);
            Assert.AreEqual("Reference", result[36].Name);
            Assert.AreEqual("Resource", result[37].Name);
            Assert.AreEqual("ResourceCompile", result[38].Name);
            Assert.AreEqual("Service", result[39].Name);
            Assert.AreEqual("StoreAssociationFile", result[40].Name);
            Assert.AreEqual("WebReferences", result[41].Name);
            Assert.AreEqual("WebReferenceUrl", result[42].Name);
            Assert.AreEqual("Xdcmake", result[43].Name);
        }

        /// <summary>
        /// /Project/Choose/Otherwise/PropertyGroup
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod15()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose", "Otherwise", "PropertyGroup" });
            Assert.AreEqual(276, result.Count);
            Assert.AreEqual("AllowUnsafeBlocks", result[0].Name);
            Assert.AreEqual("AppConfigForCompiler", result[1].Name);
            Assert.AreEqual("AppDesignerFolder", result[2].Name);
            Assert.AreEqual("ApplicationIcon", result[3].Name);
            Assert.AreEqual("ApplicationRevision", result[4].Name);
            Assert.AreEqual("ApplicationVersion", result[5].Name);
            Assert.AreEqual("AppxCreatePriFilesForPortableLibrariesAdditionalMakepriExeParameters", result[6].Name);
            Assert.AreEqual("AppxDefaultHashUri", result[7].Name);
            Assert.AreEqual("AppxExpandPriContentAdditionalMakepriExeParameters", result[8].Name);
            Assert.AreEqual("AppxGeneratePriEnabled", result[9].Name);
            Assert.AreEqual("AppxGenerateProjectPriFileAdditionalMakepriExeParameters", result[10].Name);
            Assert.AreEqual("AppxHarvestWinMDRegistration", result[11].Name);
            Assert.AreEqual("AppxLayoutDir", result[12].Name);
            Assert.AreEqual("AppxLayoutFolder", result[13].Name);
            Assert.AreEqual("AppxManifestSchema", result[14].Name);
            Assert.AreEqual("AppxMergePriFilesAdditionalMakepriExeParameters", result[15].Name);
            Assert.AreEqual("AppxPackage", result[16].Name);
            Assert.AreEqual("AppxPackageArtifactsDir", result[17].Name);
            Assert.AreEqual("AppxPackageDir", result[18].Name);
            Assert.AreEqual("AppxPackageName", result[19].Name);
            Assert.AreEqual("AppxPackageOutput", result[20].Name);
            Assert.AreEqual("AppxPackageRecipe", result[21].Name);
            Assert.AreEqual("AppxPackageSigningEnabled", result[22].Name);
            Assert.AreEqual("AppxPackageTestDir", result[23].Name);
            Assert.AreEqual("AppxPackageValidationEnabled", result[24].Name);
            Assert.AreEqual("AppxPriPrependReswInitialPath", result[25].Name);
            Assert.AreEqual("AppxPriReswInitialPath", result[26].Name);
            Assert.AreEqual("AppxSkipUnchangedFiles", result[27].Name);
            Assert.AreEqual("AppxStoreContainer", result[28].Name);
            Assert.AreEqual("AppxSymbolPackageEnabled", result[29].Name);
            Assert.AreEqual("AppxSymbolPackageOutput", result[30].Name);
            Assert.AreEqual("AppxTestLayoutEnabled", result[31].Name);
            Assert.AreEqual("AppxUseHardlinksIfPossible", result[32].Name);
            Assert.AreEqual("AspNetConfiguration", result[33].Name);
            Assert.AreEqual("AssemblyKeyContainerName", result[34].Name);
            Assert.AreEqual("AssemblyKeyProviderName", result[35].Name);
            Assert.AreEqual("AssemblyName", result[36].Name);
            Assert.AreEqual("AssemblyOriginatorKeyFile", result[37].Name);
            Assert.AreEqual("AssemblyOriginatorKeyFileType", result[38].Name);
            Assert.AreEqual("AssemblyOriginatorKeyMode", result[39].Name);
            Assert.AreEqual("AssemblyType", result[40].Name);
            Assert.AreEqual("AutoIncrementPackageRevision", result[41].Name);
            Assert.AreEqual("AutorunEnabled", result[42].Name);
            Assert.AreEqual("BaseAddress", result[43].Name);
            Assert.AreEqual("BootstrapperComponentsLocation", result[44].Name);
            Assert.AreEqual("BootstrapperComponentsUrl", result[45].Name);
            Assert.AreEqual("BootstrapperEnabled", result[46].Name);
            Assert.AreEqual("CharacterSet", result[47].Name);
            Assert.AreEqual("CheckForOverflowUnderflow", result[48].Name);
            Assert.AreEqual("CLRSupport", result[49].Name);
            Assert.AreEqual("CodeAnalysisAdditionalOptions", result[50].Name);
            Assert.AreEqual("CodeAnalysisApplyLogFileXsl", result[51].Name);
            Assert.AreEqual("CodeAnalysisConsoleXsl", result[52].Name);
            Assert.AreEqual("CodeAnalysisCulture", result[53].Name);
            Assert.AreEqual("CodeAnalysisFailOnMissingRules", result[54].Name);
            Assert.AreEqual("CodeAnalysisForceOutput", result[55].Name);
            Assert.AreEqual("CodeAnalysisGenerateSuccessFile", result[56].Name);
            Assert.AreEqual("CodeAnalysisIgnoreBuiltInRules", result[57].Name);
            Assert.AreEqual("CodeAnalysisIgnoreBuiltInRuleSets", result[58].Name);
            Assert.AreEqual("CodeAnalysisIgnoreGeneratedCode", result[59].Name);
            Assert.AreEqual("CodeAnalysisIgnoreInvalidTargets", result[60].Name);
            Assert.AreEqual("CodeAnalysisInputAssembly", result[61].Name);
            Assert.AreEqual("CodeAnalysisLogFile", result[62].Name);
            Assert.AreEqual("CodeAnalysisLogFileXsl", result[63].Name);
            Assert.AreEqual("CodeAnalysisModuleSuppressionsFile", result[64].Name);
            Assert.AreEqual("CodeAnalysisOutputToConsole", result[65].Name);
            Assert.AreEqual("CodeAnalysisOverrideRuleVisibilities", result[66].Name);
            Assert.AreEqual("CodeAnalysisPath", result[67].Name);
            Assert.AreEqual("CodeAnalysisPlatformPath", result[68].Name);
            Assert.AreEqual("CodeAnalysisProject", result[69].Name);
            Assert.AreEqual("CodeAnalysisQuiet", result[70].Name);
            Assert.AreEqual("CodeAnalysisRuleAssemblies", result[71].Name);
            Assert.AreEqual("CodeAnalysisRuleDirectories", result[72].Name);
            Assert.AreEqual("CodeAnalysisRules", result[73].Name);
            Assert.AreEqual("CodeAnalysisRuleSet", result[74].Name);
            Assert.AreEqual("CodeAnalysisRuleSetDirectories", result[75].Name);
            Assert.AreEqual("CodeAnalysisSaveMessagesToReport", result[76].Name);
            Assert.AreEqual("CodeAnalysisSearchGlobalAssemblyCache", result[77].Name);
            Assert.AreEqual("CodeAnalysisSummary", result[78].Name);
            Assert.AreEqual("CodeAnalysisTimeout", result[79].Name);
            Assert.AreEqual("CodeAnalysisTreatWarningsAsErrors", result[80].Name);
            Assert.AreEqual("CodeAnalysisUpdateProject", result[81].Name);
            Assert.AreEqual("CodeAnalysisUseTypeNameInSuppression", result[82].Name);
            Assert.AreEqual("CodeAnalysisVerbose", result[83].Name);
            Assert.AreEqual("CodePage", result[84].Name);
            Assert.AreEqual("Configuration", result[85].Name);
            Assert.AreEqual("ConfigurationName", result[86].Name);
            Assert.AreEqual("ConfigurationOverrideFile", result[87].Name);
            Assert.AreEqual("ConfigurationType", result[88].Name);
            Assert.AreEqual("CreateDesktopShortcut", result[89].Name);
            Assert.AreEqual("CreateWebPageOnPublish", result[90].Name);
            Assert.AreEqual("CurrentSolutionConfigurationContents", result[91].Name);
            Assert.AreEqual("DebugSecurityZoneURL", result[92].Name);
            Assert.AreEqual("DebugSymbols", result[93].Name);
            Assert.AreEqual("DebugType", result[94].Name);
            Assert.AreEqual("DefaultClientScript", result[95].Name);
            Assert.AreEqual("DefaultHTMLPageLayout", result[96].Name);
            Assert.AreEqual("DefaultTargetSchema", result[97].Name);
            Assert.AreEqual("DefineConstants", result[98].Name);
            Assert.AreEqual("DefineDebug", result[99].Name);
            Assert.AreEqual("DefineTrace", result[100].Name);
            Assert.AreEqual("DelaySign", result[101].Name);
            Assert.AreEqual("DeployDirSuffix", result[102].Name);
            Assert.AreEqual("DisableFastUpToDateCheck", result[103].Name);
            Assert.AreEqual("DisableLangXtns", result[104].Name);
            Assert.AreEqual("DisallowUrlActivation", result[105].Name);
            Assert.AreEqual("DocumentationFile", result[106].Name);
            Assert.AreEqual("EmbedManifest", result[107].Name);
            Assert.AreEqual("EnableASPDebugging", result[108].Name);
            Assert.AreEqual("EnableASPXDebugging", result[109].Name);
            Assert.AreEqual("EnableSecurityDebugging", result[110].Name);
            Assert.AreEqual("EnableSQLServerDebugging", result[111].Name);
            Assert.AreEqual("EnableUnmanagedDebugging", result[112].Name);
            Assert.AreEqual("ErrorReport", result[113].Name);
            Assert.AreEqual("ErrorReportUrl", result[114].Name);
            Assert.AreEqual("ExcludeDeploymentUrl", result[115].Name);
            Assert.AreEqual("ExcludedPermissions", result[116].Name);
            Assert.AreEqual("FallbackCulture", result[117].Name);
            Assert.AreEqual("FileAlignment", result[118].Name);
            Assert.AreEqual("FileUpgradeFlags", result[119].Name);
            Assert.AreEqual("FinalAppxManifestName", result[120].Name);
            Assert.AreEqual("FinalAppxPackageRecipe", result[121].Name);
            Assert.AreEqual("FinalPriFileName", result[122].Name);
            Assert.AreEqual("FinalPriFullPath", result[123].Name);
            Assert.AreEqual("FormFactorID", result[124].Name);
            Assert.AreEqual("FrameworkPathOverride", result[125].Name);
            Assert.AreEqual("GenerateManifests", result[126].Name);
            Assert.AreEqual("GenerateSerializationAssemblies", result[127].Name);
            Assert.AreEqual("HighEntropyVA", result[128].Name);
            Assert.AreEqual("HostInBrowser", result[129].Name);
            Assert.AreEqual("IgnoreImportLibrary", result[130].Name);
            Assert.AreEqual("IncludeBuiltProjectOutputGroup", result[131].Name);
            Assert.AreEqual("IncludeComFilesOutputGroup", result[132].Name);
            Assert.AreEqual("IncludeContentFilesProjectOutputGroup", result[133].Name);
            Assert.AreEqual("IncludeCopyLocalFilesOutputGroup", result[134].Name);
            Assert.AreEqual("IncludeCopyWinMDArtifactsOutputGroup", result[135].Name);
            Assert.AreEqual("IncludeCustomOutputGroupForPackaging", result[136].Name);
            Assert.AreEqual("IncludeDebugSymbolsProjectOutputGroup", result[137].Name);
            Assert.AreEqual("IncludeDocumentationProjectOutputGroup", result[138].Name);
            Assert.AreEqual("IncludeGetResolvedSDKReferences", result[139].Name);
            Assert.AreEqual("IncludePriFilesOutputGroup", result[140].Name);
            Assert.AreEqual("IncludeSatelliteDllsProjectOutputGroup", result[141].Name);
            Assert.AreEqual("IncludeSDKRedistOutputGroup", result[142].Name);
            Assert.AreEqual("IncludeSGenFilesOutputGroup", result[143].Name);
            Assert.AreEqual("IncludeSourceFilesProjectOutputGroup", result[144].Name);
            Assert.AreEqual("Install", result[145].Name);
            Assert.AreEqual("InstallFrom", result[146].Name);
            Assert.AreEqual("InstallUrl", result[147].Name);
            Assert.AreEqual("IsWebBootstrapper", result[148].Name);
            Assert.AreEqual("JCPA", result[149].Name);
            Assert.AreEqual("Keyword", result[150].Name);
            Assert.AreEqual("LangVersion", result[151].Name);
            Assert.AreEqual("LinkIncremental", result[152].Name);
            Assert.AreEqual("MakePriExeFullPath", result[153].Name);
            Assert.AreEqual("ManagedWinMDInprocImplementation", result[154].Name);
            Assert.AreEqual("ManifestCertificateThumbprint", result[155].Name);
            Assert.AreEqual("ManifestKeyFile", result[156].Name);
            Assert.AreEqual("MapFileExtensions", result[157].Name);
            Assert.AreEqual("MinimumRequiredVersion", result[158].Name);
            Assert.AreEqual("MyType", result[159].Name);
            Assert.AreEqual("NoConfig", result[160].Name);
            Assert.AreEqual("NoStandardLibraries", result[161].Name);
            Assert.AreEqual("NoStdLib", result[162].Name);
            Assert.AreEqual("NoWarn", result[163].Name);
            Assert.AreEqual("OldToolsVersion", result[164].Name);
            Assert.AreEqual("OpenBrowserOnPublish", result[165].Name);
            Assert.AreEqual("Optimize", result[166].Name);
            Assert.AreEqual("OptionCompare", result[167].Name);
            Assert.AreEqual("OptionExplicit", result[168].Name);
            Assert.AreEqual("OptionInfer", result[169].Name);
            Assert.AreEqual("OptionStrict", result[170].Name);
            Assert.AreEqual("OSVersion", result[171].Name);
            Assert.AreEqual("OutDir", result[172].Name);
            Assert.AreEqual("OutputPath", result[173].Name);
            Assert.AreEqual("OutputType", result[174].Name);
            Assert.AreEqual("Platform", result[175].Name);
            Assert.AreEqual("PlatformFamilyName", result[176].Name);
            Assert.AreEqual("PlatformID", result[177].Name);
            Assert.AreEqual("PlatformName", result[178].Name);
            Assert.AreEqual("PlatformTarget", result[179].Name);
            Assert.AreEqual("PlatformToolset", result[180].Name);
            Assert.AreEqual("PostBuildEvent", result[181].Name);
            Assert.AreEqual("PreBuildEvent", result[182].Name);
            Assert.AreEqual("Prefer32Bit", result[183].Name);
            Assert.AreEqual("ProductName", result[184].Name);
            Assert.AreEqual("ProductVersion", result[185].Name);
            Assert.AreEqual("ProjectGuid", result[186].Name);
            Assert.AreEqual("ProjectPriFileName", result[187].Name);
            Assert.AreEqual("ProjectType", result[188].Name);
            Assert.AreEqual("ProjectTypeGuids", result[189].Name);
            Assert.AreEqual("PublisherName", result[190].Name);
            Assert.AreEqual("PublishUrl", result[191].Name);
            Assert.AreEqual("RecursePath", result[192].Name);
            Assert.AreEqual("ReferencePath", result[193].Name);
            Assert.AreEqual("RegisterForComInterop", result[194].Name);
            Assert.AreEqual("RemoteDebugEnabled", result[195].Name);
            Assert.AreEqual("RemoteDebugMachine", result[196].Name);
            Assert.AreEqual("RemoveIntegerChecks", result[197].Name);
            Assert.AreEqual("ResponseFile", result[198].Name);
            Assert.AreEqual("RootNamespace", result[199].Name);
            Assert.AreEqual("RunCodeAnalysis", result[200].Name);
            Assert.AreEqual("RunPostBuildEvent", result[201].Name);
            Assert.AreEqual("SccLocalPath", result[202].Name);
            Assert.AreEqual("SccProjectName", result[203].Name);
            Assert.AreEqual("SccProvider", result[204].Name);
            Assert.AreEqual("SchemaVersion", result[205].Name);
            Assert.AreEqual("SecureScoping", result[206].Name);
            Assert.AreEqual("SignAssembly", result[207].Name);
            Assert.AreEqual("SignManifests", result[208].Name);
            Assert.AreEqual("SolutionDir", result[209].Name);
            Assert.AreEqual("SolutionExt", result[210].Name);
            Assert.AreEqual("SolutionFileName", result[211].Name);
            Assert.AreEqual("SolutionName", result[212].Name);
            Assert.AreEqual("SolutionPath", result[213].Name);
            Assert.AreEqual("StartAction", result[214].Name);
            Assert.AreEqual("StartArguments", result[215].Name);
            Assert.AreEqual("StartPage", result[216].Name);
            Assert.AreEqual("StartProgram", result[217].Name);
            Assert.AreEqual("StartupObject", result[218].Name);
            Assert.AreEqual("StartURL", result[219].Name);
            Assert.AreEqual("StartWithIE", result[220].Name);
            Assert.AreEqual("StartWorkingDirectory", result[221].Name);
            Assert.AreEqual("SuiteName", result[222].Name);
            Assert.AreEqual("SupportUrl", result[223].Name);
            Assert.AreEqual("TargetCulture", result[224].Name);
            Assert.AreEqual("TargetExt", result[225].Name);
            Assert.AreEqual("TargetFrameworkProfile", result[226].Name);
            Assert.AreEqual("TargetFrameworkVersion", result[227].Name);
            Assert.AreEqual("TargetName", result[228].Name);
            Assert.AreEqual("TargetPlatformIdentifier", result[229].Name);
            Assert.AreEqual("TargetPlatformVersion", result[230].Name);
            Assert.AreEqual("TargetZone", result[231].Name);
            Assert.AreEqual("TreatWarningsAsErrors", result[232].Name);
            Assert.AreEqual("TrustUrlParameters", result[233].Name);
            Assert.AreEqual("TypeComplianceDiagnostics", result[234].Name);
            Assert.AreEqual("UICulture", result[235].Name);
            Assert.AreEqual("UpdateEnabled", result[236].Name);
            Assert.AreEqual("UpdateInterval", result[237].Name);
            Assert.AreEqual("UpdateIntervalUnits", result[238].Name);
            Assert.AreEqual("UpdateMode", result[239].Name);
            Assert.AreEqual("UpdatePeriodically", result[240].Name);
            Assert.AreEqual("UpdateRequired", result[241].Name);
            Assert.AreEqual("UpdateUrl", result[242].Name);
            Assert.AreEqual("UpgradeBackupLocation", result[243].Name);
            Assert.AreEqual("UseAppConfigForCompiler", result[244].Name);
            Assert.AreEqual("UseApplicationTrust", result[245].Name);
            Assert.AreEqual("UseDebugLibraries", result[246].Name);
            Assert.AreEqual("UseIncrementalAppxRegistration", result[247].Name);
            Assert.AreEqual("UseOfAtl", result[248].Name);
            Assert.AreEqual("UseOfMfc", result[249].Name);
            Assert.AreEqual("UseVSHostingProcess", result[250].Name);
            Assert.AreEqual("UTF8OutPut", result[251].Name);
            Assert.AreEqual("VBRuntime", result[252].Name);
            Assert.AreEqual("VCTargetsPath", result[253].Name);
            Assert.AreEqual("VSTO_TrustAssembliesLocation", result[254].Name);
            Assert.AreEqual("WarningLevel", result[255].Name);
            Assert.AreEqual("WarningsAsErrors", result[256].Name);
            Assert.AreEqual("WcfConfigValidationEnabled", result[257].Name);
            Assert.AreEqual("WebPage", result[258].Name);
            Assert.AreEqual("WholeProgramOptimization", result[259].Name);
            Assert.AreEqual("Win32ResourceFile", result[260].Name);
            Assert.AreEqual("WsdlXsdCodeGenCollectionTypes", result[261].Name);
            Assert.AreEqual("WsdlXsdCodeGenEnabled", result[262].Name);
            Assert.AreEqual("WsdlXsdCodeGenEnableDataBinding", result[263].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateAsynchronousOperations", result[264].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateDataTypesOnly", result[265].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateInternalTypes", result[266].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateMessageContract", result[267].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateSerializableTypes", result[268].Name);
            Assert.AreEqual("WsdlXsdCodeGenImportXmlTypes", result[269].Name);
            Assert.AreEqual("WsdlXsdCodeGenNamespaceMappings", result[270].Name);
            Assert.AreEqual("WsdlXsdCodeGenReuseTypesFlag", result[271].Name);
            Assert.AreEqual("WsdlXsdCodeGenReuseTypesMode", result[272].Name);
            Assert.AreEqual("WsdlXsdCodeGenSerializerMode", result[273].Name);
            Assert.AreEqual("WsdlXsdCodeGenUseSerializerForFaults", result[274].Name);
            Assert.AreEqual("WsdlXsdCodeGenWrapped", result[275].Name);
        }

        /// <summary>
        /// /Project/Choose/When
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod16()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Choose", "When" });
            Assert.AreEqual(3, result.Count);
            Assert.AreEqual("Choose", result[0].Name);
            Assert.AreEqual("ItemGroup", result[1].Name);
            Assert.AreEqual("PropertyGroup", result[2].Name);

        }

        #endregion

        #region /Project/Import
        /// <summary>
        /// /Project/Import
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod17()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Import" });
            Assert.AreEqual(0, result.Count);
        }
        #endregion

        #region /Project/ImportGroup
        /// <summary>
        /// /Project/ImportGroup
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod18()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ImportGroup" });
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual("Import", result[0].Name);
        }
        #endregion

        #region /Project/ItemDefinitionGroup
        /// <summary>
        /// /Project/ItemDefinitionGroup
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod19()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemDefinitionGroup" });
            Assert.AreEqual(44, result.Count);
            Assert.AreEqual("ApplicationDefinition", result[0].Name);
            Assert.AreEqual("AppxManifest", result[1].Name);
            Assert.AreEqual("AppxManifestFileNameQuery", result[2].Name);
            Assert.AreEqual("AppxReservedFileName", result[3].Name);
            Assert.AreEqual("AppxSystemBinary", result[4].Name);
            Assert.AreEqual("BaseApplicationManifest", result[5].Name);
            Assert.AreEqual("BootstrapperFile", result[6].Name);
            Assert.AreEqual("Bscmake", result[7].Name);
            Assert.AreEqual("ClCompile", result[8].Name);
            Assert.AreEqual("ClInclude", result[9].Name);
            Assert.AreEqual("CodeAnalysisDependentAssemblyPaths", result[10].Name);
            Assert.AreEqual("CodeAnalysisDictionary", result[11].Name);
            Assert.AreEqual("CodeAnalysisImport", result[12].Name);
            Assert.AreEqual("COMFileReference", result[13].Name);
            Assert.AreEqual("Compile", result[14].Name);
            Assert.AreEqual("COMReference", result[15].Name);
            Assert.AreEqual("Content", result[16].Name);
            Assert.AreEqual("CustomBuildStep", result[17].Name);
            Assert.AreEqual("EmbeddedResource", result[18].Name);
            Assert.AreEqual("FileAssociation", result[19].Name);
            Assert.AreEqual("Folder", result[20].Name);
            Assert.AreEqual("Import", result[21].Name);
            Assert.AreEqual("Link", result[22].Name);
            Assert.AreEqual("Manifest", result[23].Name);
            Assert.AreEqual("Midl", result[24].Name);
            Assert.AreEqual("NativeReference", result[25].Name);
            Assert.AreEqual("None", result[26].Name);
            Assert.AreEqual("Page", result[27].Name);
            Assert.AreEqual("PostBuildEvent", result[28].Name);
            Assert.AreEqual("PreBuildEvent", result[29].Name);
            Assert.AreEqual("PreLinkEvent", result[30].Name);
            Assert.AreEqual("PRIResource", result[31].Name);
            Assert.AreEqual("ProjectCapability", result[32].Name);
            Assert.AreEqual("ProjectConfiguration", result[33].Name);
            Assert.AreEqual("ProjectReference", result[34].Name);
            Assert.AreEqual("PublishFile", result[35].Name);
            Assert.AreEqual("Reference", result[36].Name);
            Assert.AreEqual("Resource", result[37].Name);
            Assert.AreEqual("ResourceCompile", result[38].Name);
            Assert.AreEqual("Service", result[39].Name);
            Assert.AreEqual("StoreAssociationFile", result[40].Name);
            Assert.AreEqual("WebReferences", result[41].Name);
            Assert.AreEqual("WebReferenceUrl", result[42].Name);
            Assert.AreEqual("Xdcmake", result[43].Name);
        }
        #endregion

        #region /Project/ItemGroup
        /// <summary>
        /// /Project/ItemGroup
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod20()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup" });
            Assert.AreEqual(44, result.Count);
            Assert.AreEqual("ApplicationDefinition", result[0].Name);
            Assert.AreEqual("AppxManifest", result[1].Name);
            Assert.AreEqual("AppxManifestFileNameQuery", result[2].Name);
            Assert.AreEqual("AppxReservedFileName", result[3].Name);
            Assert.AreEqual("AppxSystemBinary", result[4].Name);
            Assert.AreEqual("BaseApplicationManifest", result[5].Name);
            Assert.AreEqual("BootstrapperFile", result[6].Name);
            Assert.AreEqual("Bscmake", result[7].Name);
            Assert.AreEqual("ClCompile", result[8].Name);
            Assert.AreEqual("ClInclude", result[9].Name);
            Assert.AreEqual("CodeAnalysisDependentAssemblyPaths", result[10].Name);
            Assert.AreEqual("CodeAnalysisDictionary", result[11].Name);
            Assert.AreEqual("CodeAnalysisImport", result[12].Name);
            Assert.AreEqual("COMFileReference", result[13].Name);
            Assert.AreEqual("Compile", result[14].Name);
            Assert.AreEqual("COMReference", result[15].Name);
            Assert.AreEqual("Content", result[16].Name);
            Assert.AreEqual("CustomBuildStep", result[17].Name);
            Assert.AreEqual("EmbeddedResource", result[18].Name);
            Assert.AreEqual("FileAssociation", result[19].Name);
            Assert.AreEqual("Folder", result[20].Name);
            Assert.AreEqual("Import", result[21].Name);
            Assert.AreEqual("Link", result[22].Name);
            Assert.AreEqual("Manifest", result[23].Name);
            Assert.AreEqual("Midl", result[24].Name);
            Assert.AreEqual("NativeReference", result[25].Name);
            Assert.AreEqual("None", result[26].Name);
            Assert.AreEqual("Page", result[27].Name);
            Assert.AreEqual("PostBuildEvent", result[28].Name);
            Assert.AreEqual("PreBuildEvent", result[29].Name);
            Assert.AreEqual("PreLinkEvent", result[30].Name);
            Assert.AreEqual("PRIResource", result[31].Name);
            Assert.AreEqual("ProjectCapability", result[32].Name);
            Assert.AreEqual("ProjectConfiguration", result[33].Name);
            Assert.AreEqual("ProjectReference", result[34].Name);
            Assert.AreEqual("PublishFile", result[35].Name);
            Assert.AreEqual("Reference", result[36].Name);
            Assert.AreEqual("Resource", result[37].Name);
            Assert.AreEqual("ResourceCompile", result[38].Name);
            Assert.AreEqual("Service", result[39].Name);
            Assert.AreEqual("StoreAssociationFile", result[40].Name);
            Assert.AreEqual("WebReferences", result[41].Name);
            Assert.AreEqual("WebReferenceUrl", result[42].Name);
            Assert.AreEqual("Xdcmake", result[43].Name);
        }

        #region /Project/ItemGroup/ApplicationDefinition
        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod21()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition" });
            Assert.AreEqual(8, result.Count);
            Assert.AreEqual("CopyToOutputDirectory", result[0].Name);
            Assert.AreEqual("CustomToolNamespace", result[1].Name);
            Assert.AreEqual("DependentUpon", result[2].Name);
            Assert.AreEqual("Generator", result[3].Name);
            Assert.AreEqual("Group", result[4].Name);
            Assert.AreEqual("LastGenOutput", result[5].Name);
            Assert.AreEqual("Link", result[6].Name);
            Assert.AreEqual("SubType", result[7].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/CopyToOutputDirectory
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod22()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "CopyToOutputDirectory" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/CustomToolNamespace
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod23()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "CustomToolNamespace" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/DependentUpon
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod24()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "DependentUpon" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/Generator
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod25()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "Generator" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/Group
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod26()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "Group" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/LastGenOutput
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod27()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "LastGenOutput" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/Link
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod28()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "Link" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ApplicationDefinition/SubType
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod29()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ApplicationDefinition", "SubType" });
            Assert.AreEqual(0, result.Count);
        }
#endregion

        #region /Project/ItemGroup/AppManifest
        /// <summary>
        /// /Project/ItemGroup/AppxManifest
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod30()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "AppxManifest" });
            Assert.AreEqual(3, result.Count);
            Assert.AreEqual("DependentUpon", result[0].Name);
            Assert.AreEqual("Link", result[1].Name);
            Assert.AreEqual("Visible", result[2].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/AppxManifest/DependentUpon
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod31()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "AppxManifest", "DependentUpon" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/AppxManifest/Link
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod32()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "AppxManifest", "Link" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/AppxManifest/Visible
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod33()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "AppxManifest", "Visible" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/AppxManifestFileNameQuery
        /// <summary>
        /// /Project/ItemGroup/AppxManifestFileNameQuery
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod34()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "AppxManifestFileNameQuery" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/AppxReservedFileName
        /// <summary>
        /// /Project/ItemGroup/AppxReservedFileName
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod35()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "AppxReservedFileName" });
            Assert.AreEqual(0, result.Count);
        }


        #endregion

        #region /Project/ItemGroup/AppxSystemBinary
        /// <summary>
        /// /Project/ItemGroup/AppxSystemBinary
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod37()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "AppxSystemBinary" });
            Assert.AreEqual(0, result.Count);
        }


        #endregion

        #region /Project/ItemGroup/BaseApplicationManifest
        /// <summary>
        /// /Project/ItemGroup/BaseApplicationManifest
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod38()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "BaseApplicationManifest" });
            Assert.AreEqual(0, result.Count);
        }


        #endregion

        #region /Project/ItemGroup/BootstrapperFile
        /// <summary>
        /// /Project/ItemGroup/BootstrapperFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod40()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "BootstrapperFile" });
            Assert.AreEqual(3, result.Count);
            Assert.AreEqual("Install", result[0].Name);
            Assert.AreEqual("ProductName", result[1].Name);
            Assert.AreEqual("Visible", result[2].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/BootstrapperFile/Install
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod41()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "BootstrapperFile", "Install" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/BootstrapperFile/ProductName
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod42()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "BootstrapperFile", "ProductName" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/BootstrapperFile/Visible
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod43()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "BootstrapperFile", "Visible" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/Bscmake
        /// <summary>
        /// /Project/ItemGroup/Bscmake
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod44()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Bscmake" });
            Assert.AreEqual(4, result.Count);
            Assert.AreEqual("AdditionalOptions", result[0].Name);
            Assert.AreEqual("OutputFile", result[1].Name);
            Assert.AreEqual("PreserveSBR", result[2].Name);
            Assert.AreEqual("SuppressStartupBanner", result[3].Name);

        }

        /// <summary>
        /// /Project/ItemGroup/Bscmake/AdditionalOptions
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod45()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Bscmake", "AdditionalOptions" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Bscmake/OutputFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod46()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Bscmake", "OutputFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Bscmake/PreserveSBR
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod47()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Bscmake", "PreserveSBR" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Bscmake/SuppressStartupBanner
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod48()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Bscmake", "SuppressStartupBanner" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/ClCompile
        /// <summary>
        /// /Project/ItemGroup/ClCompile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod49()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile" });
            Assert.AreEqual(33, result.Count);
            Assert.AreEqual("AdditionalIncludeDirectories", result[0].Name);
            Assert.AreEqual("AdditionalUsingDirectories", result[1].Name);
            Assert.AreEqual("BasicRuntimeChecks", result[2].Name);
            Assert.AreEqual("BrowseInformation", result[3].Name);
            Assert.AreEqual("CallingConvention", result[4].Name);
            Assert.AreEqual("CompileAsManaged", result[5].Name);
            Assert.AreEqual("CreateHotpatchableImage", result[6].Name);
            Assert.AreEqual("DebugInformationFormat", result[7].Name);
            Assert.AreEqual("DisableSpecificWarnings", result[8].Name);
            Assert.AreEqual("ErrorReporting", result[9].Name);
            Assert.AreEqual("FloatingPointExceptions", result[10].Name);
            Assert.AreEqual("FloatingPointModel", result[11].Name);
            Assert.AreEqual("ForcedIncludeFiles", result[12].Name);
            Assert.AreEqual("ForcedUsingFiles", result[13].Name);
            Assert.AreEqual("FunctionLevelLinking", result[14].Name);
            Assert.AreEqual("IntrinsicFunctions", result[15].Name);
            Assert.AreEqual("MinimalRebuild", result[16].Name);
            Assert.AreEqual("MultiProcessorCompilation", result[17].Name);
            Assert.AreEqual("OmitDefaultLibName", result[18].Name);
            Assert.AreEqual("OpenMPSupport", result[19].Name);
            Assert.AreEqual("Optimization", result[20].Name);
            Assert.AreEqual("PrecompiledHeader", result[21].Name);
            Assert.AreEqual("PrecompiledHeaderFile", result[22].Name);
            Assert.AreEqual("PreprocessorDefinitions", result[23].Name);
            Assert.AreEqual("RuntimeLibrary", result[24].Name);
            Assert.AreEqual("RuntimeTypeInfo", result[25].Name);
            Assert.AreEqual("ShowIncludes", result[26].Name);
            Assert.AreEqual("StringPooling", result[27].Name);
            Assert.AreEqual("TreatSpecificWarningsAsErrors", result[28].Name);
            Assert.AreEqual("UndefinePreprocessorDefinitions", result[29].Name);
            Assert.AreEqual("UseFullPaths", result[30].Name);
            Assert.AreEqual("UseUnicodeForAssemblerListing", result[31].Name);
            Assert.AreEqual("WarningLevel", result[32].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/AdditionalIncludeDirectories
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod50()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "AdditionalIncludeDirectories" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/AdditionalUsingDirectories
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod51()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "AdditionalUsingDirectories" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/BasicRuntimeChecks
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod52()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "BasicRuntimeChecks" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/BrowseInformation
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod53()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "BrowseInformation" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/CallingConvention
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod54()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "CallingConvention" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/CompileAsManaged
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod55()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "CompileAsManaged" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/CreateHotpatchableImage
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod56()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "CreateHotpatchableImage" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/DebugInformationFormat
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod57()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "DebugInformationFormat" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/DisableSpecificWarnings
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod58()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "DisableSpecificWarnings" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/ErrorReporting
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod59()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "ErrorReporting" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/FloatingPointExceptions
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod60()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "FloatingPointExceptions" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/FloatingPointModel
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod61()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "FloatingPointModel" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/ForcedIncludeFiles
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod62()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "ForcedIncludeFiles" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/ForcedUsingFiles
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod63()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "ForcedUsingFiles" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/FunctionLevelLinking
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod64()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "FunctionLevelLinking" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/IntrinsicFunctions
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod65()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "IntrinsicFunctions" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/MinimalRebuild
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod66()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "MinimalRebuild" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/MultiProcessorCompilation
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod67()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "MultiProcessorCompilation" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/OmitDefaultLibName
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod68()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "OmitDefaultLibName" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/OpenMPSupport
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod69()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "OpenMPSupport" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/Optimization
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod70()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "Optimization" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/PrecompiledHeader
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod71()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "PrecompiledHeader" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/PrecompiledHeaderFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod72()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "PrecompiledHeaderFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/PreprocessorDefinitions
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod73()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "PreprocessorDefinitions" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/RuntimeLibrary
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod74()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "RuntimeLibrary" });
            Assert.AreEqual(0, result.Count);

        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/RuntimeTypeInfo
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod75()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "RuntimeTypeInfo" });
            Assert.AreEqual(0, result.Count);

        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/ShowIncludes
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod76()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "ShowIncludes" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/StringPooling
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod77()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "StringPooling" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/TreatSpecificWarningsAsErrors
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod78()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "TreatSpecificWarningsAsErrors" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/UndefinePreprocessorDefinitions
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod79()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "UndefinePreprocessorDefinitions" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/UseFullPaths
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod80()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "UseFullPaths" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/UseUnicodeForAssemblerListing
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod81()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "UseUnicodeForAssemblerListing" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/ClCompile/WarningLevel
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod82()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClCompile", "WarningLevel" });
            Assert.AreEqual(0, result.Count);
        }


        #endregion

        #region /Project/ItemGroup/ClInclude
        /// <summary>
        /// /Project/ItemGroup/ClInclude
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod83()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClInclude" });
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual("AdditionalIncludeDirectories", result[0].Name);

        }

        /// <summary>
        /// /Project/ItemGroup/ClInclude/AdditionalIncludeDirectories
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod84()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ClInclude", "AdditionalIncludeDirectories" });
            Assert.AreEqual(0, result.Count);

        }

        #endregion

        #region /Project/ItemGroup/CodeAnalysisDependentAssemblyPaths
        /// <summary>
        /// /Project/ItemGroup/CodeAnalysisDependentAssemblyPaths
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod85()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CodeAnalysisDependentAssemblyPaths" });
            Assert.AreEqual(0, result.Count);

        }

        
        #endregion

        #region /Project/ItemGroup/CodeAnalysisDictionary
        /// <summary>
        /// /Project/ItemGroup/CodeAnalysisDependentAssemblyPaths
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod86()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CodeAnalysisDictionary" });
            Assert.AreEqual(0, result.Count);

        }


        #endregion

        #region /Project/ItemGroup/CodeAnalysisImport
        /// <summary>
        /// /Project/ItemGroup/CodeAnalysisDependentAssemblyPaths
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod87()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CodeAnalysisImport" });
            Assert.AreEqual(0, result.Count);

        }


        #endregion

        #region /Project/ItemGroup/COMFileReference
        /// <summary>
        /// /Project/ItemGroup/COMFileReference
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod88()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "COMFileReference" });
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual("WrapperTool", result[0].Name);

        }

        /// <summary>
        /// /Project/ItemGroup/COMFileReference/WrapperTool
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod89()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "COMFileReference", "WrapperTool" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/Content
        /// <summary>
        /// /Project/ItemGroup/Content
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod90()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content" });
            Assert.AreEqual(11, result.Count);
            Assert.AreEqual("CopyToOutputDirectory", result[0].Name);
            Assert.AreEqual("CustomToolNamespace", result[1].Name);
            Assert.AreEqual("DependentUpon", result[2].Name);
            Assert.AreEqual("Generator", result[3].Name);
            Assert.AreEqual("Group", result[4].Name);
            Assert.AreEqual("IsAssembly", result[5].Name);
            Assert.AreEqual("LastGenOutput", result[6].Name);
            Assert.AreEqual("Link", result[7].Name);
            Assert.AreEqual("PublishState", result[8].Name);
            Assert.AreEqual("SubType", result[9].Name);
            Assert.AreEqual("Visible", result[10].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/CopyToOutputDirectory
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod91()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "CopyToOutputDirectory" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/CustomToolNamespace
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod92()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "CustomToolNamespace" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/DependentUpon
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod93()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "DependentUpon" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/Generator
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod94()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "Generator" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/Group
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod95()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "Group" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/IsAssembly
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod96()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "IsAssembly" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/LastGenOutput
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod97()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "LastGenOutput" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/Link
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod98()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "Link" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/PublishState
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod99()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "PublishState" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/SubType
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod100()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "SubType" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Content/Visible
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod101()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Content", "Visible" });
            Assert.AreEqual(0, result.Count);
        }


        #endregion

        #region /Project/ItemGroup/CustomBuildStep
        /// <summary>
        /// /Project/ItemGroup/CustomBuildStep
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod102()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CustomBuildStep" });
            Assert.AreEqual(4, result.Count);
            Assert.AreEqual("Command", result[0].Name);
            Assert.AreEqual("Inputs", result[1].Name);
            Assert.AreEqual("Message", result[2].Name);
            Assert.AreEqual("Outputs", result[3].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/CustomBuildStep/Command
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod103()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CustomBuildStep", "Command" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/CustomBuildStep/Inputs
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod104()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CustomBuildStep", "Inputs" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/CustomBuildStep/Message
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod105()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CustomBuildStep", "Message" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/CustomBuildStep/Outputs
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod106()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "CustomBuildStep", "Outputs" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/EmbeddedResource
        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod107()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource" });
            Assert.AreEqual(9, result.Count);
            Assert.AreEqual("CopyToOutputDirectory", result[0].Name);
            Assert.AreEqual("CustomToolNamespace", result[1].Name);
            Assert.AreEqual("DependentUpon", result[2].Name);
            Assert.AreEqual("Generator", result[3].Name);
            Assert.AreEqual("LastGenOutput", result[4].Name);
            Assert.AreEqual("Link", result[5].Name);
            Assert.AreEqual("LogicalName", result[6].Name);
            Assert.AreEqual("SubType", result[7].Name);
            Assert.AreEqual("Visible", result[8].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/CopyToOutputDirectory
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod108()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "CopyToOutputDirectory" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/CustomToolNamespace
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod109()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "CustomToolNamespace" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/DependentUpon
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod110()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "DependentUpon" });
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/Generator
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod111()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "Generator" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/LastGenOutput
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod112()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "LastGenOutput" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/Link
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod113()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "Link" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/LogicalName
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod114()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "LogicalName" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/SubType
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod115()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "SubType" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/EmbeddedResource/Visible
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod116()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "EmbeddedResource", "Visible" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/FileAssociation
        /// <summary>
        /// /Project/ItemGroup/FileAssociation
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod117()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "FileAssociation" });
            Assert.AreEqual(4, result.Count);
            Assert.AreEqual("DefaultIcon", result[0].Name);
            Assert.AreEqual("Description", result[1].Name);
            Assert.AreEqual("Progid", result[2].Name);
            Assert.AreEqual("Visible", result[3].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/FileAssociation/DefaultIcon
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod118()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "FileAssociation", "DefaultIcon" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/FileAssociation/Description
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod119()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "FileAssociation", "Description" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/FileAssociation/Progid
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod120()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "FileAssociation", "Progid" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/FileAssociation/Visible
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod121()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "FileAssociation", "Visible" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/Folder
        /// <summary>
        /// /Project/ItemGroup/Folder
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod122()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Folder" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/Import
        /// <summary>
        /// /Project/ItemGroup/Import
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod123()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Import" });
            Assert.AreEqual(0, result.Count);
        }

        #endregion

        #region /Project/ItemGroup/Link
        /// <summary>
        /// /Project/ItemGroup/Link
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod124()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link" });
            Assert.AreEqual(77, result.Count);
            Assert.AreEqual("AdditionalDependencies", result[0].Name);
            Assert.AreEqual("AdditionalLibraryDirectories", result[1].Name);
            Assert.AreEqual("AdditionalManifestDependencies", result[2].Name);
            Assert.AreEqual("AddModuleNamesToAssembly", result[3].Name);
            Assert.AreEqual("AllowIsolation", result[4].Name);
            Assert.AreEqual("AssemblyDebug", result[5].Name);
            Assert.AreEqual("AssemblyLinkResource", result[6].Name);
            Assert.AreEqual("BaseAddress", result[7].Name);
            Assert.AreEqual("CLRImageType", result[8].Name);
            Assert.AreEqual("CLRSupportLastError", result[9].Name);
            Assert.AreEqual("CLRThreadAttribute", result[10].Name);
            Assert.AreEqual("CLRUnmanagedCodeCheck", result[11].Name);
            Assert.AreEqual("CreateHotPatchableImage", result[12].Name);
            Assert.AreEqual("DataExecutionPrevention", result[13].Name);
            Assert.AreEqual("DelayLoadDLLs", result[14].Name);
            Assert.AreEqual("DelaySign", result[15].Name);
            Assert.AreEqual("Driver", result[16].Name);
            Assert.AreEqual("EmbedManagedResourceFile", result[17].Name);
            Assert.AreEqual("EnableCOMDATFolding", result[18].Name);
            Assert.AreEqual("EnableUAC", result[19].Name);
            Assert.AreEqual("EntryPointSymbol", result[20].Name);
            Assert.AreEqual("FixedBaseAddress", result[21].Name);
            Assert.AreEqual("ForceFileOutput", result[22].Name);
            Assert.AreEqual("ForceSymbolReferences", result[23].Name);
            Assert.AreEqual("FunctionOrder", result[24].Name);
            Assert.AreEqual("GenerateDebugInformation", result[25].Name);
            Assert.AreEqual("GenerateMapFile", result[26].Name);
            Assert.AreEqual("HeapCommitSize", result[27].Name);
            Assert.AreEqual("HeapReserveSize", result[28].Name);
            Assert.AreEqual("IgnoreAllDefaultLibraries", result[29].Name);
            Assert.AreEqual("IgnoreEmbeddedIDL", result[30].Name);
            Assert.AreEqual("IgnoreSpecificDefaultLibraries", result[31].Name);
            Assert.AreEqual("IgnoreStandardIncludePath", result[32].Name);
            Assert.AreEqual("ImageHasSafeExceptionHandlers", result[33].Name);
            Assert.AreEqual("ImportLibrary", result[34].Name);
            Assert.AreEqual("KeyContainer", result[35].Name);
            Assert.AreEqual("KeyFile", result[36].Name);
            Assert.AreEqual("LargeAddressAware", result[37].Name);
            Assert.AreEqual("LinkErrorReporting", result[38].Name);
            Assert.AreEqual("LinkStatus", result[39].Name);
            Assert.AreEqual("LinkTimeCodeGeneration", result[40].Name);
            Assert.AreEqual("MapExports", result[41].Name);
            Assert.AreEqual("MapFileName", result[42].Name);
            Assert.AreEqual("MergedIDLBaseFileName", result[43].Name);
            Assert.AreEqual("MergeSections", result[44].Name);
            Assert.AreEqual("MidlCommandFile", result[45].Name);
            Assert.AreEqual("MinimumRequiredVersion", result[46].Name);
            Assert.AreEqual("ModuleDefinitionFile", result[47].Name);
            Assert.AreEqual("MSDOSStubFileName", result[48].Name);
            Assert.AreEqual("OptimizeReferences", result[49].Name);
            Assert.AreEqual("OutputFile", result[50].Name);
            Assert.AreEqual("PreventDllBinding", result[51].Name);
            Assert.AreEqual("Profile", result[52].Name);
            Assert.AreEqual("ProfileGuidedDatabase", result[53].Name);
            Assert.AreEqual("ProgramDatabaseFile", result[54].Name);
            Assert.AreEqual("RandomizedBaseAddress", result[55].Name);
            Assert.AreEqual("RegisterOutput", result[56].Name);
            Assert.AreEqual("SectionAlignment", result[57].Name);
            Assert.AreEqual("ShowProgress", result[58].Name);
            Assert.AreEqual("SpecifySectionAttributes", result[59].Name);
            Assert.AreEqual("StackCommitSize", result[60].Name);
            Assert.AreEqual("StackReserveSize", result[61].Name);
            Assert.AreEqual("StripPrivateSymbols", result[62].Name);
            Assert.AreEqual("SubSystem", result[63].Name);
            Assert.AreEqual("SupportNobindOfDelayLoadedDLL", result[64].Name);
            Assert.AreEqual("SupportUnloadOfDelayLoadedDLL", result[65].Name);
            Assert.AreEqual("SuppressStartupBanner", result[66].Name);
            Assert.AreEqual("SwapRunFromCD", result[67].Name);
            Assert.AreEqual("SwapRunFromNET", result[68].Name);
            Assert.AreEqual("TargetMachine", result[69].Name);
            Assert.AreEqual("TerminalServerAware", result[70].Name);
            Assert.AreEqual("TreatLinkerWarningAsErrors", result[71].Name);
            Assert.AreEqual("TypeLibraryFile", result[72].Name);
            Assert.AreEqual("TypeLibraryResourceID", result[73].Name);
            Assert.AreEqual("UACExecutionLevel", result[74].Name);
            Assert.AreEqual("UACUIAccess", result[75].Name);
            Assert.AreEqual("Version", result[76].Name);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/AdditionalDependencies
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod125()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "AdditionalDependencies" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/AdditionalLibraryDirectories
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod126()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "AdditionalLibraryDirectories" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/AddModuleNamesToAssembly
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod127()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "AddModuleNamesToAssembly" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/AllowIsolation
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod128()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "AllowIsolation" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/AssemblyDebug
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod129()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "AssemblyDebug" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/AssemblyLinkResource
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod130()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "AssemblyLinkResource" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/BaseAddress
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod131()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "BaseAddress" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/CLRImageType
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod132()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "CLRImageType" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/CLRSupportLastError
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod133()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "CLRSupportLastError" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/CLRThreadAttribute
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod134()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "CLRThreadAttribute" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/CLRUnmanagedCodeCheck
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod135()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "CLRUnmanagedCodeCheck" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/CreateHotPatchableImage
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod136()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "CreateHotPatchableImage" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/DataExecutionPrevention
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod137()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "DataExecutionPrevention" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/DelayLoadDLLs
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod138()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "DelayLoadDLLs" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/DelaySign
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod139()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "DelaySign" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/Driver
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod140()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "Driver" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/EmbedManagedResourceFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod141()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "EmbedManagedResourceFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/EnableCOMDATFolding
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod142()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "EnableCOMDATFolding" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/EnableUAC
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod143()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "EnableUAC" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/EntryPointSymbol
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod144()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "EntryPointSymbol" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/FixedBaseAddress
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod145()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "FixedBaseAddress" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ForceFileOutput
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod146()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ForceFileOutput" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ForceSymbolReferences
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod147()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ForceSymbolReferences" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/FunctionOrder
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod148()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "FunctionOrder" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/GenerateDebugInformation
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod149()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "GenerateDebugInformation" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/GenerateMapFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod150()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "GenerateMapFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/HeapCommitSize
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod151()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "HeapCommitSize" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/HeapReserveSize
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod152()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "HeapReserveSize" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/IgnoreAllDefaultLibraries
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod153()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "IgnoreAllDefaultLibraries" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/IgnoreEmbeddedIDL
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod154()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "IgnoreEmbeddedIDL" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/IgnoreSpecificDefaultLibraries
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod155()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "IgnoreSpecificDefaultLibraries" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/IgnoreStandardIncludePath
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod156()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "IgnoreStandardIncludePath" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ImageHasSafeExceptionHandlers
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod157()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ImageHasSafeExceptionHandlers" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ImportLibrary
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod158()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ImportLibrary" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/KeyContainer
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod159()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "KeyContainer" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/KeyFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod160()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "KeyFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/LargeAddressAware
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod161()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "LargeAddressAware" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/LinkErrorReporting
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod162()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "LinkErrorReporting" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/LinkStatus
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod163()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "LinkStatus" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/LinkTimeCodeGeneration
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod164()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "LinkTimeCodeGeneration" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/MapExports
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod165()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "MapExports" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/MapFileName
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod166()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "MapFileName" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/MergedIDLBaseFileName
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod167()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "MergedIDLBaseFileName" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/MergeSections
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod168()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "MergeSections" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/MidlCommandFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod169()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "MidlCommandFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/MinimumRequiredVersion
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod170()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "MinimumRequiredVersion" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ModuleDefinitionFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod171()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ModuleDefinitionFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/MSDOSStubFileName
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod172()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "MSDOSStubFileName" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/OptimizeReferences
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod173()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "OptimizeReferences" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/OutputFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod174()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "OutputFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/PreventDllBinding
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod175()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "PreventDllBinding" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/Profile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod176()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "Profile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ProfileGuidedDatabase
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod177()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ProfileGuidedDatabase" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ProgramDatabaseFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod178()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ProgramDatabaseFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/RandomizedBaseAddress
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod179()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "RandomizedBaseAddress" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/RegisterOutput
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod180()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "RegisterOutput" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SectionAlignment
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod181()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SectionAlignment" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/ShowProgress
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod182()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "ShowProgress" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SpecifySectionAttributes
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod183()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SpecifySectionAttributes" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/StackCommitSize
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod184()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "StackCommitSize" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/StackReserveSize
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod185()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "StackReserveSize" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/StripPrivateSymbols
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod186()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "StripPrivateSymbols" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SubSystem
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod187()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SubSystem" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SupportNobindOfDelayLoadedDLL
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod188()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SupportNobindOfDelayLoadedDLL" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SupportUnloadOfDelayLoadedDLL
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod189()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SupportUnloadOfDelayLoadedDLL" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SuppressStartupBanner
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod190()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SuppressStartupBanner" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SwapRunFromCD
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod191()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SwapRunFromCD" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/SwapRunFromNET
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod192()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "SwapRunFromNET" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/TargetMachine
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod193()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "TargetMachine" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/TerminalServerAware
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod194()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "TerminalServerAware" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/TreatLinkerWarningAsErrors
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod195()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "TreatLinkerWarningAsErrors" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/TypeLibraryFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod196()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "TypeLibraryFile" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/TypeLibraryResourceID
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod197()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "TypeLibraryResourceID" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/UACExecutionLevel
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod198()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "UACExecutionLevel" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/UACUIAccess
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod199()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "UACUIAccess" });
            Assert.AreEqual(0, result.Count);
        }

        /// <summary>
        /// /Project/ItemGroup/Link/Version
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod200()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Link", "Version" });
            Assert.AreEqual(0, result.Count);
        }


        #endregion

        #region /Project/ItemGroup/Manifest
        /// <summary>
        /// /Project/ItemGroup/Manifest
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod201()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Manifest" });
            Assert.AreEqual(20, result.Count);
            Assert.AreEqual("AdditionalManifestFiles", result[0].Name);
            Assert.AreEqual("AdditionalOptions", result[1].Name);
            Assert.AreEqual("AssemblyIdentity", result[2].Name);
            Assert.AreEqual("ComponentFileName", result[3].Name);
            Assert.AreEqual("DependencyInformationFile", result[4].Name);
            Assert.AreEqual("EnableDPIAwareness", result[5].Name);
            Assert.AreEqual("GenerateCatalogFiles", result[6].Name);
            Assert.AreEqual("GenerateCategoryTags", result[7].Name);
            Assert.AreEqual("InputResourceManifests", result[8].Name);
            Assert.AreEqual("ManifestFromManagedAssembly", result[9].Name);
            Assert.AreEqual("OutputManifestFile", result[10].Name);
            Assert.AreEqual("OutputResourceManifests", result[11].Name);
            Assert.AreEqual("RegistrarScriptFile", result[12].Name);
            Assert.AreEqual("ReplacementsFile", result[13].Name);
            Assert.AreEqual("ResourceOutputFileName", result[14].Name);
            Assert.AreEqual("SuppressDependencyElement", result[15].Name);
            Assert.AreEqual("SuppressStartupBanner", result[16].Name);
            Assert.AreEqual("TypeLibraryFile", result[17].Name);
            Assert.AreEqual("UpdateFileHashesSearchPath", result[18].Name);
            Assert.AreEqual("VerboseOutput", result[19].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, 
                new string[] { "Project", "ItemGroup", "Manifest", "AdditionalManifestFiles" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, 
                new string[] { "Project", "ItemGroup", "Manifest", "AdditionalOptions" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "AssemblyIdentity" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "ComponentFileName" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "DependencyInformationFile" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "EnableDPIAwareness" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "GenerateCatalogFiles" });
            Assert.AreEqual(0, result7.Count);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "GenerateCategoryTags" });
            Assert.AreEqual(0, result8.Count);
            List<XmlSchemaElement> result9 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "InputResourceManifests" });
            Assert.AreEqual(0, result9.Count);
            List<XmlSchemaElement> result10 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "ManifestFromManagedAssembly" });
            Assert.AreEqual(0, result10.Count);
            List<XmlSchemaElement> result11 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "OutputManifestFile" });
            Assert.AreEqual(0, result11.Count);
            List<XmlSchemaElement> result12 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "OutputResourceManifests" });
            Assert.AreEqual(0, result12.Count);
            List<XmlSchemaElement> result13 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "RegistrarScriptFile" });
            Assert.AreEqual(0, result13.Count);
            List<XmlSchemaElement> result14 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "ReplacementsFile" });
            Assert.AreEqual(0, result14.Count);
            List<XmlSchemaElement> result15 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "ResourceOutputFileName" });
            Assert.AreEqual(0, result15.Count);
            List<XmlSchemaElement> result16 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "SuppressDependencyElement" });
            Assert.AreEqual(0, result16.Count);
            List<XmlSchemaElement> result17 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "SuppressStartupBanner" });
            Assert.AreEqual(0, result17.Count);
            List<XmlSchemaElement> result18 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "TypeLibraryFile" });
            Assert.AreEqual(0, result18.Count);
            List<XmlSchemaElement> result19 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "UpdateFileHashesSearchPath" });
            Assert.AreEqual(0, result19.Count);
            List<XmlSchemaElement> result20 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Manifest", "VerboseOutput" });
            Assert.AreEqual(0, result20.Count);

        }

        #endregion

        #region /Project/ItemGroup/Midl
        /// <summary>
        /// /Project/ItemGroup/Midl
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod202()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Midl" });
            Assert.AreEqual(36, result.Count);
            Assert.AreEqual("AdditionalIncludeDirectories", result[0].Name);
            Assert.AreEqual("AdditionalOptions", result[1].Name);
            Assert.AreEqual("ApplicationConfigurationMode", result[2].Name);
            Assert.AreEqual("ClientStubFile", result[3].Name);
            Assert.AreEqual("CPreprocessOptions", result[4].Name);
            Assert.AreEqual("DefaultCharType", result[5].Name);
            Assert.AreEqual("DllDataFileName", result[6].Name);
            Assert.AreEqual("EnableErrorChecks", result[7].Name);
            Assert.AreEqual("ErrorCheckAllocations", result[8].Name);
            Assert.AreEqual("ErrorCheckBounds", result[9].Name);
            Assert.AreEqual("ErrorCheckEnumRange", result[10].Name);
            Assert.AreEqual("ErrorCheckRefPointers", result[11].Name);
            Assert.AreEqual("ErrorCheckStubData", result[12].Name);
            Assert.AreEqual("GenerateClientFiles", result[13].Name);
            Assert.AreEqual("GenerateServerFiles", result[14].Name);
            Assert.AreEqual("GenerateStublessProxies", result[15].Name);
            Assert.AreEqual("GenerateTypeLibrary", result[16].Name);
            Assert.AreEqual("HeaderFileName", result[17].Name);
            Assert.AreEqual("IgnoreStandardIncludePath", result[18].Name);
            Assert.AreEqual("InterfaceIdentifierFileName", result[19].Name);
            Assert.AreEqual("LocaleID", result[20].Name);
            Assert.AreEqual("MkTypLibCompatible", result[21].Name);
            Assert.AreEqual("OutputDirectory", result[22].Name);
            Assert.AreEqual("PreprocessorDefinitions", result[23].Name);
            Assert.AreEqual("ProxyFileName", result[24].Name);
            Assert.AreEqual("RedirectOutputAndErrors", result[25].Name);
            Assert.AreEqual("ServerStubFile", result[26].Name);
            Assert.AreEqual("StructMemberAlignment", result[27].Name);
            Assert.AreEqual("SuppressCompilerWarnings", result[28].Name);
            Assert.AreEqual("SuppressStartupBanner", result[29].Name);
            Assert.AreEqual("TargetEnvironment", result[30].Name);
            Assert.AreEqual("TypeLibFormat", result[31].Name);
            Assert.AreEqual("TypeLibraryName", result[32].Name);
            Assert.AreEqual("UndefinePreprocessorDefinitions", result[33].Name);
            Assert.AreEqual("ValidateAllParameters", result[34].Name);
            Assert.AreEqual("WarnAsError", result[35].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "AdditionalIncludeDirectories" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "AdditionalOptions" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ApplicationConfigurationMode" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ClientStubFile" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "CPreprocessOptions" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "DefaultCharType" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "DllDataFileName" });
            Assert.AreEqual(0, result7.Count);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "EnableErrorChecks" });
            Assert.AreEqual(0, result8.Count);
            List<XmlSchemaElement> result9 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ErrorCheckAllocations" });
            Assert.AreEqual(0, result9.Count);
            List<XmlSchemaElement> result10 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ErrorCheckBounds" });
            Assert.AreEqual(0, result10.Count);
            List<XmlSchemaElement> result11 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ErrorCheckEnumRange" });
            Assert.AreEqual(0, result11.Count);
            List<XmlSchemaElement> result12 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ErrorCheckRefPointers" });
            Assert.AreEqual(0, result12.Count);
            List<XmlSchemaElement> result13 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ErrorCheckStubData" });
            Assert.AreEqual(0, result13.Count);
            List<XmlSchemaElement> result14 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "GenerateClientFiles" });
            Assert.AreEqual(0, result14.Count);
            List<XmlSchemaElement> result15 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "GenerateServerFiles" });
            Assert.AreEqual(0, result15.Count);
            List<XmlSchemaElement> result16 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "GenerateStublessProxies" });
            Assert.AreEqual(0, result16.Count);
            List<XmlSchemaElement> result17 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "GenerateTypeLibrary" });
            Assert.AreEqual(0, result17.Count);
            List<XmlSchemaElement> result18 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "HeaderFileName" });
            Assert.AreEqual(0, result18.Count);
            List<XmlSchemaElement> result19 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "IgnoreStandardIncludePath" });
            Assert.AreEqual(0, result19.Count);
            List<XmlSchemaElement> result20 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "InterfaceIdentifierFileName" });
            Assert.AreEqual(0, result20.Count);
            List<XmlSchemaElement> result21 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "LocaleID" });
            Assert.AreEqual(0, result21.Count);
            List<XmlSchemaElement> result22 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "MkTypLibCompatible" });
            Assert.AreEqual(0, result22.Count);
            List<XmlSchemaElement> result23 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "OutputDirectory" });
            Assert.AreEqual(0, result23.Count);
            List<XmlSchemaElement> result24 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "PreprocessorDefinitions" });
            Assert.AreEqual(0, result24.Count);
            List<XmlSchemaElement> result25 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ProxyFileName" });
            Assert.AreEqual(0, result25.Count);
            List<XmlSchemaElement> result26 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "RedirectOutputAndErrors" });
            Assert.AreEqual(0, result26.Count);
            List<XmlSchemaElement> result27 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ServerStubFile" });
            Assert.AreEqual(0, result27.Count);
            List<XmlSchemaElement> result28 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "StructMemberAlignment" });
            Assert.AreEqual(0, result28.Count);
            List<XmlSchemaElement> result29 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "SuppressCompilerWarnings" });
            Assert.AreEqual(0, result29.Count);
            List<XmlSchemaElement> result30 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "SuppressStartupBanner" });
            Assert.AreEqual(0, result30.Count);
            List<XmlSchemaElement> result31 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "TargetEnvironment" });
            Assert.AreEqual(0, result31.Count);
            List<XmlSchemaElement> result32 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "TypeLibFormat" });
            Assert.AreEqual(0, result32.Count);
            List<XmlSchemaElement> result33 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "TypeLibraryName" });
            Assert.AreEqual(0, result33.Count);
            List<XmlSchemaElement> result34 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "UndefinePreprocessorDefinitions" });
            Assert.AreEqual(0, result34.Count);
            List<XmlSchemaElement> result35 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "ValidateAllParameters" });
            Assert.AreEqual(0, result35.Count);
            List<XmlSchemaElement> result36 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Midl", "WarnAsError" });
            Assert.AreEqual(0, result36.Count);

        }

        #endregion

        #region /Project/ItemGroup/NativeReference
        /// <summary>
        /// /Project/ItemGroup/NativeReference
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod203()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "NativeReference" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("HintPath", result[0].Name);
            Assert.AreEqual("Name", result[1].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "NativeReference", "HintPath" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "NativeReference", "Name" });
            Assert.AreEqual(0, result2.Count);
        }
        #endregion

        #region /Project/ItemGroup/None
        /// <summary>
        /// /Project/ItemGroup/None
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod204()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "None" });
            Assert.AreEqual(7, result.Count);
            Assert.AreEqual("CopyToOutputDirectory", result[0].Name);
            Assert.AreEqual("CustomToolNamespace", result[1].Name);
            Assert.AreEqual("DependentUpon", result[2].Name);
            Assert.AreEqual("Generator", result[3].Name);
            Assert.AreEqual("LastGenOutput", result[4].Name);
            Assert.AreEqual("Link", result[5].Name);
            Assert.AreEqual("Visible", result[6].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "None", "CopyToOutputDirectory" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "None", "CustomToolNamespace" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "None", "DependentUpon" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "None", "Generator" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "None", "LastGenOutput" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "None", "Link" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "None", "Visible" });
            Assert.AreEqual(0, result7.Count);
        }
        #endregion

        #region /Project/ItemGroup/Page
        /// <summary>
        /// /Project/ItemGroup/Page
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod205()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Page" });
            Assert.AreEqual(8, result.Count);
            Assert.AreEqual("CopyToOutputDirectory", result[0].Name);
            Assert.AreEqual("CustomToolNamespace", result[1].Name);
            Assert.AreEqual("DependentUpon", result[2].Name);
            Assert.AreEqual("Generator", result[3].Name);
            Assert.AreEqual("Group", result[4].Name);
            Assert.AreEqual("LastGenOutput", result[5].Name);
            Assert.AreEqual("Link", result[6].Name);
            Assert.AreEqual("SubType", result[7].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "CopyToOutputDirectory" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "CustomToolNamespace" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "DependentUpon" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "Generator" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "Group" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "LastGenOutput" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "Link" });
            Assert.AreEqual(0, result7.Count);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Page", "SubType" });
            Assert.AreEqual(0, result8.Count);
        }

        #endregion

        #region /Project/ItemGroup/PostBuildEvent
        /// <summary>
        /// /Project/ItemGroup/PostBuildEvent
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod206()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "PostBuildEvent" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("Command", result[0].Name);
            Assert.AreEqual("Message", result[1].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PostBuildEvent", "Command" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PostBuildEvent", "Message" });
            Assert.AreEqual(0, result2.Count);
        }
        #endregion

        #region /Project/ItemGroup/PreBuildEvent
        /// <summary>
        /// /Project/ItemGroup/PreBuildEvent
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod207()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "PreBuildEvent" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("Command", result[0].Name);
            Assert.AreEqual("Message", result[1].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PreBuildEvent", "Command" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PreBuildEvent", "Message" });
            Assert.AreEqual(0, result2.Count);
        }
        #endregion

        #region /Project/ItemGroup/PreLinkEvent
        /// <summary>
        /// /Project/ItemGroup/PreLinkEvent
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod208()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "PreLinkEvent" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("Command", result[0].Name);
            Assert.AreEqual("Message", result[1].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PreLinkEvent", "Command" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PreLinkEvent", "Message" });
            Assert.AreEqual(0, result2.Count);
        }
        #endregion

        #region /Project/ItemGroup/PRIResource
        /// <summary>
        /// /Project/ItemGroup/PreLinkEvent
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod209()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "PreLinkEvent" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("Command", result[0].Name);
            Assert.AreEqual("Message", result[1].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PreLinkEvent", "Command" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PreLinkEvent", "Message" });
            Assert.AreEqual(0, result2.Count);
        }
        #endregion

        #region /Project/ItemGroup/ProjectCapability
        /// <summary>
        /// /Project/ItemGroup/ProjectCapability
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod210()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ProjectCapability" });
            Assert.AreEqual(0, result.Count);
        }
        #endregion

        #region /Project/ItemGroup/ProjectConfiguration
        /// <summary>
        /// /Project/ItemGroup/ProjectConfiguration
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod211()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ProjectConfiguration" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("Configuration", result[0].Name);
            Assert.AreEqual("Platform", result[1].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectConfiguration", "Configuration" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectConfiguration", "Platform" });
            Assert.AreEqual(0, result2.Count);
        }

        #endregion

        #region /Project/ItemGroup/ProjectReference
        /// <summary>
        /// /Project/ItemGroup/ProjectReference
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod212()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ProjectReference" });
            Assert.AreEqual(8, result.Count);
            Assert.AreEqual("EmbedInteropTypes", result[0].Name);
            Assert.AreEqual("Name", result[1].Name);
            Assert.AreEqual("OutputItemType", result[2].Name);
            Assert.AreEqual("Package", result[3].Name);
            Assert.AreEqual("Project", result[4].Name);
            Assert.AreEqual("ReferenceOutputAssembly", result[5].Name);
            Assert.AreEqual("SpecificVersion", result[6].Name);
            Assert.AreEqual("Targets", result[7].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "EmbedInteropTypes" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "Name" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "OutputItemType" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "Package" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "Project" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "ReferenceOutputAssembly" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "SpecificVersion" });
            Assert.AreEqual(0, result7.Count);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ProjectReference", "Targets" });
            Assert.AreEqual(0, result8.Count);
        }
        #endregion

        #region /Project/ItemGroup/PublishFile
        /// <summary>
        /// /Project/ItemGroup/PublishFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod213()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "PublishFile" });
            Assert.AreEqual(5, result.Count);
            Assert.AreEqual("Group", result[0].Name);
            Assert.AreEqual("IncludeHash", result[1].Name);
            Assert.AreEqual("IsAssembly", result[2].Name);
            Assert.AreEqual("PublishState", result[3].Name);
            Assert.AreEqual("Visible", result[4].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PublishFile", "Group" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PublishFile", "IncludeHash" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PublishFile", "IsAssembly" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PublishFile", "PublishState" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "PublishFile", "Visible" });
            Assert.AreEqual(0, result5.Count);
        }
        #endregion

        #region /Project/ItemGroup/Reference
        /// <summary>
        /// /Project/ItemGroup/Reference
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod214()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Reference" });
            Assert.AreEqual(8, result.Count);
            Assert.AreEqual("Aliases", result[0].Name);
            Assert.AreEqual("EmbedInteropTypes", result[1].Name);
            Assert.AreEqual("FusionName", result[2].Name);
            Assert.AreEqual("HintPath", result[3].Name);
            Assert.AreEqual("Name", result[4].Name);
            Assert.AreEqual("Private", result[5].Name);
            Assert.AreEqual("RequiredTargetFramework", result[6].Name);
            Assert.AreEqual("SpecificVersion", result[7].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "Aliases" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "EmbedInteropTypes" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "FusionName" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "HintPath" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "Name" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "Private" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "RequiredTargetFramework" });
            Assert.AreEqual(0, result7.Count);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Reference", "SpecificVersion" });
            Assert.AreEqual(0, result8.Count);
        }
        #endregion

        #region /Project/ItemGroup/Resource
        /// <summary>
        /// /Project/ItemGroup/Resource
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod215()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Resource" });
            Assert.AreEqual(8, result.Count);
            Assert.AreEqual("CopyToOutputDirectory", result[0].Name);
            Assert.AreEqual("CustomToolNamespace", result[1].Name);
            Assert.AreEqual("DependentUpon", result[2].Name);
            Assert.AreEqual("Generator", result[3].Name);
            Assert.AreEqual("Group", result[4].Name);
            Assert.AreEqual("LastGenOutput", result[5].Name);
            Assert.AreEqual("Link", result[6].Name);
            Assert.AreEqual("SubType", result[7].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Resource", "CopyToOutputDirectory" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Resource", "CustomToolNamespace" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Resource", "DependentUpon" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Resource", "Generator" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Resource", "Group" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
               new string[] { "Project", "ItemGroup", "Resource", "LastGenOutput" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Resource", "Link" });
            Assert.AreEqual(0, result7.Count);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Resource", "SubType" });
            Assert.AreEqual(0, result8.Count);
        }
        #endregion

        #region /Project/ItemGroup/ResourceCompile
        /// <summary>
        /// /Project/ItemGroup/ResourceCompile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod216()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "ResourceCompile" });
            Assert.AreEqual(3, result.Count);
            Assert.AreEqual("AdditionalIncludeDirectories", result[0].Name);
            Assert.AreEqual("Culture", result[1].Name);
            Assert.AreEqual("PreprocessorDefinitions", result[2].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ResourceCompile", "AdditionalIncludeDirectories" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ResourceCompile", "Culture" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "ResourceCompile", "PreprocessorDefinitions" });
            Assert.AreEqual(0, result5.Count);
        }
        #endregion

        #region /Project/ItemGroup/Service
        /// <summary>
        /// /Project/ItemGroup/Service
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod217()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Service" });
            Assert.AreEqual(0, result.Count);

        }
        #endregion

        #region /Project/ItemGroup/StoreAssociationFile
        /// <summary>
        /// /Project/ItemGroup/StoreAssociationFile
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod218()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "StoreAssociationFile" });
            Assert.AreEqual(3, result.Count);
            Assert.AreEqual("DependentUpon", result[0].Name);
            Assert.AreEqual("Link", result[1].Name);
            Assert.AreEqual("Visible", result[2].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "StoreAssociationFile", "DependentUpon" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "StoreAssociationFile", "Link" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "StoreAssociationFile", "Visible" });
            Assert.AreEqual(0, result5.Count);
        }
        #endregion

        #region /Project/ItemGroup/WebReferences
        /// <summary>
        /// /Project/ItemGroup/WebReferences
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod219()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "WebReferences" });
            Assert.AreEqual(0, result.Count);

        }
        #endregion

        #region /Project/ItemGroup/WebReferenceUrl
        /// <summary>
        /// /Project/ItemGroup/WebReferenceUrl
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod220()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "WebReferenceUrl" });
            Assert.AreEqual(7, result.Count);
            Assert.AreEqual("CachedAppSettingsObjectName", result[0].Name);
            Assert.AreEqual("CachedDynamicPropName", result[1].Name);
            Assert.AreEqual("CachedSettingsPropName", result[2].Name);
            Assert.AreEqual("RelPath", result[3].Name);
            Assert.AreEqual("ServiceLocationURL", result[4].Name);
            Assert.AreEqual("UpdateFromURL", result[5].Name);
            Assert.AreEqual("UrlBehavior", result[6].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "WebReferenceUrl", "CachedAppSettingsObjectName" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "WebReferenceUrl", "CachedDynamicPropName" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "WebReferenceUrl", "CachedSettingsPropName" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "WebReferenceUrl", "RelPath" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "WebReferenceUrl", "ServiceLocationURL" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "WebReferenceUrl", "UpdateFromURL" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "WebReferenceUrl", "UrlBehavior" });
            Assert.AreEqual(0, result7.Count);
        }
        #endregion

        #region /Project/ItemGroup/Xdcmake
        /// <summary>
        /// /Project/ItemGroup/Xdcmake
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod221()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ItemGroup", "Xdcmake" });
            Assert.AreEqual(3, result.Count);
            Assert.AreEqual("AdditionalDocumentFile", result[0].Name);
            Assert.AreEqual("DocumentLibraryDependencies", result[1].Name);
            Assert.AreEqual("SuppressStartupBanner", result[2].Name);

            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Xdcmake", "AdditionalDocumentFile" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Xdcmake", "DocumentLibraryDependencies" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "ItemGroup", "Xdcmake", "SuppressStartupBanner" });
            Assert.AreEqual(0, result3.Count);
        }
        #endregion

        #endregion

        #region /Project/ProjectExtensions

        /// <summary>
        /// /Project/ProjectExtensions
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod222()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "ProjectExtensions" });
            Assert.AreEqual(0, result.Count);

        }
        #endregion

        #region /Project/PropertyGroup

        /// <summary>
        /// /Project/PropertyGroup
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod223()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "PropertyGroup" });
            Assert.AreEqual(276, result.Count);
            Assert.AreEqual("AllowUnsafeBlocks", result[0].Name);
            Assert.AreEqual("AppConfigForCompiler", result[1].Name);
            Assert.AreEqual("AppDesignerFolder", result[2].Name);
            Assert.AreEqual("ApplicationIcon", result[3].Name);
            Assert.AreEqual("ApplicationRevision", result[4].Name);
            Assert.AreEqual("ApplicationVersion", result[5].Name);
            Assert.AreEqual("AppxCreatePriFilesForPortableLibrariesAdditionalMakepriExeParameters", result[6].Name);
            Assert.AreEqual("AppxDefaultHashUri", result[7].Name);
            Assert.AreEqual("AppxExpandPriContentAdditionalMakepriExeParameters", result[8].Name);
            Assert.AreEqual("AppxGeneratePriEnabled", result[9].Name);
            Assert.AreEqual("AppxGenerateProjectPriFileAdditionalMakepriExeParameters", result[10].Name);
            Assert.AreEqual("AppxHarvestWinMDRegistration", result[11].Name);
            Assert.AreEqual("AppxLayoutDir", result[12].Name);
            Assert.AreEqual("AppxLayoutFolder", result[13].Name);
            Assert.AreEqual("AppxManifestSchema", result[14].Name);
            Assert.AreEqual("AppxMergePriFilesAdditionalMakepriExeParameters", result[15].Name);
            Assert.AreEqual("AppxPackage", result[16].Name);
            Assert.AreEqual("AppxPackageArtifactsDir", result[17].Name);
            Assert.AreEqual("AppxPackageDir", result[18].Name);
            Assert.AreEqual("AppxPackageName", result[19].Name);
            Assert.AreEqual("AppxPackageOutput", result[20].Name);
            Assert.AreEqual("AppxPackageRecipe", result[21].Name);
            Assert.AreEqual("AppxPackageSigningEnabled", result[22].Name);
            Assert.AreEqual("AppxPackageTestDir", result[23].Name);
            Assert.AreEqual("AppxPackageValidationEnabled", result[24].Name);
            Assert.AreEqual("AppxPriPrependReswInitialPath", result[25].Name);
            Assert.AreEqual("AppxPriReswInitialPath", result[26].Name);
            Assert.AreEqual("AppxSkipUnchangedFiles", result[27].Name);
            Assert.AreEqual("AppxStoreContainer", result[28].Name);
            Assert.AreEqual("AppxSymbolPackageEnabled", result[29].Name);
            Assert.AreEqual("AppxSymbolPackageOutput", result[30].Name);
            Assert.AreEqual("AppxTestLayoutEnabled", result[31].Name);
            Assert.AreEqual("AppxUseHardlinksIfPossible", result[32].Name);
            Assert.AreEqual("AspNetConfiguration", result[33].Name);
            Assert.AreEqual("AssemblyKeyContainerName", result[34].Name);
            Assert.AreEqual("AssemblyKeyProviderName", result[35].Name);
            Assert.AreEqual("AssemblyName", result[36].Name);
            Assert.AreEqual("AssemblyOriginatorKeyFile", result[37].Name);
            Assert.AreEqual("AssemblyOriginatorKeyFileType", result[38].Name);
            Assert.AreEqual("AssemblyOriginatorKeyMode", result[39].Name);
            Assert.AreEqual("AssemblyType", result[40].Name);
            Assert.AreEqual("AutoIncrementPackageRevision", result[41].Name);
            Assert.AreEqual("AutorunEnabled", result[42].Name);
            Assert.AreEqual("BaseAddress", result[43].Name);
            Assert.AreEqual("BootstrapperComponentsLocation", result[44].Name);
            Assert.AreEqual("BootstrapperComponentsUrl", result[45].Name);
            Assert.AreEqual("BootstrapperEnabled", result[46].Name);
            Assert.AreEqual("CharacterSet", result[47].Name);
            Assert.AreEqual("CheckForOverflowUnderflow", result[48].Name);
            Assert.AreEqual("CLRSupport", result[49].Name);
            Assert.AreEqual("CodeAnalysisAdditionalOptions", result[50].Name);
            Assert.AreEqual("CodeAnalysisApplyLogFileXsl", result[51].Name);
            Assert.AreEqual("CodeAnalysisConsoleXsl", result[52].Name);
            Assert.AreEqual("CodeAnalysisCulture", result[53].Name);
            Assert.AreEqual("CodeAnalysisFailOnMissingRules", result[54].Name);
            Assert.AreEqual("CodeAnalysisForceOutput", result[55].Name);
            Assert.AreEqual("CodeAnalysisGenerateSuccessFile", result[56].Name);
            Assert.AreEqual("CodeAnalysisIgnoreBuiltInRules", result[57].Name);
            Assert.AreEqual("CodeAnalysisIgnoreBuiltInRuleSets", result[58].Name);
            Assert.AreEqual("CodeAnalysisIgnoreGeneratedCode", result[59].Name);
            Assert.AreEqual("CodeAnalysisIgnoreInvalidTargets", result[60].Name);
            Assert.AreEqual("CodeAnalysisInputAssembly", result[61].Name);
            Assert.AreEqual("CodeAnalysisLogFile", result[62].Name);
            Assert.AreEqual("CodeAnalysisLogFileXsl", result[63].Name);
            Assert.AreEqual("CodeAnalysisModuleSuppressionsFile", result[64].Name);
            Assert.AreEqual("CodeAnalysisOutputToConsole", result[65].Name);
            Assert.AreEqual("CodeAnalysisOverrideRuleVisibilities", result[66].Name);
            
            Assert.AreEqual("CodeAnalysisPath", result[67].Name);
            Assert.AreEqual("CodeAnalysisPlatformPath", result[68].Name);
            Assert.AreEqual("CodeAnalysisProject", result[69].Name);
            Assert.AreEqual("CodeAnalysisQuiet", result[70].Name);
            Assert.AreEqual("CodeAnalysisRuleAssemblies", result[71].Name);
            Assert.AreEqual("CodeAnalysisRuleDirectories", result[72].Name);
            Assert.AreEqual("CodeAnalysisRules", result[73].Name);
            Assert.AreEqual("CodeAnalysisRuleSet", result[74].Name);
            Assert.AreEqual("CodeAnalysisRuleSetDirectories", result[75].Name);
            Assert.AreEqual("CodeAnalysisSaveMessagesToReport", result[76].Name);
            Assert.AreEqual("CodeAnalysisSearchGlobalAssemblyCache", result[77].Name);
            Assert.AreEqual("CodeAnalysisSummary", result[78].Name);
            Assert.AreEqual("CodeAnalysisTimeout", result[79].Name);
            Assert.AreEqual("CodeAnalysisTreatWarningsAsErrors", result[80].Name);
            Assert.AreEqual("CodeAnalysisUpdateProject", result[81].Name);
            Assert.AreEqual("CodeAnalysisUseTypeNameInSuppression", result[82].Name);
            Assert.AreEqual("CodeAnalysisVerbose", result[83].Name);
            Assert.AreEqual("CodePage", result[84].Name);
            Assert.AreEqual("Configuration", result[85].Name);
            Assert.AreEqual("ConfigurationName", result[86].Name);
            Assert.AreEqual("ConfigurationOverrideFile", result[87].Name);
            Assert.AreEqual("ConfigurationType", result[88].Name);
            Assert.AreEqual("CreateDesktopShortcut", result[89].Name);
            Assert.AreEqual("CreateWebPageOnPublish", result[90].Name);
            
            Assert.AreEqual("CurrentSolutionConfigurationContents", result[91].Name);
            Assert.AreEqual("DebugSecurityZoneURL", result[92].Name);
            Assert.AreEqual("DebugSymbols", result[93].Name);
            Assert.AreEqual("DebugType", result[94].Name);
            Assert.AreEqual("DefaultClientScript", result[95].Name);
            Assert.AreEqual("DefaultHTMLPageLayout", result[96].Name);
            Assert.AreEqual("DefaultTargetSchema", result[97].Name);
            Assert.AreEqual("DefineConstants", result[98].Name);
            Assert.AreEqual("DefineDebug", result[99].Name);
            Assert.AreEqual("DefineTrace", result[100].Name);
            Assert.AreEqual("DelaySign", result[101].Name);
            Assert.AreEqual("DeployDirSuffix", result[102].Name);
            Assert.AreEqual("DisableFastUpToDateCheck", result[103].Name);
            Assert.AreEqual("DisableLangXtns", result[104].Name);
            Assert.AreEqual("DisallowUrlActivation", result[105].Name);
            Assert.AreEqual("DocumentationFile", result[106].Name);
            Assert.AreEqual("EmbedManifest", result[107].Name);
            Assert.AreEqual("EnableASPDebugging", result[108].Name);
            Assert.AreEqual("EnableASPXDebugging", result[109].Name);
            Assert.AreEqual("EnableSecurityDebugging", result[110].Name);
            Assert.AreEqual("EnableSQLServerDebugging", result[111].Name);
            Assert.AreEqual("EnableUnmanagedDebugging", result[112].Name);
            Assert.AreEqual("ErrorReport", result[113].Name);
            Assert.AreEqual("ErrorReportUrl", result[114].Name);
            Assert.AreEqual("ExcludeDeploymentUrl", result[115].Name);
            
            Assert.AreEqual("ExcludedPermissions", result[116].Name);
            Assert.AreEqual("FallbackCulture", result[117].Name);
            Assert.AreEqual("FileAlignment", result[118].Name);
            Assert.AreEqual("FileUpgradeFlags", result[119].Name);
            Assert.AreEqual("FinalAppxManifestName", result[120].Name);
            Assert.AreEqual("FinalAppxPackageRecipe", result[121].Name);
            Assert.AreEqual("FinalPriFileName", result[122].Name);
            Assert.AreEqual("FinalPriFullPath", result[123].Name);
            Assert.AreEqual("FormFactorID", result[124].Name);
            Assert.AreEqual("FrameworkPathOverride", result[125].Name);
            Assert.AreEqual("GenerateManifests", result[126].Name);
            Assert.AreEqual("GenerateSerializationAssemblies", result[127].Name);
            Assert.AreEqual("HighEntropyVA", result[128].Name);
            Assert.AreEqual("HostInBrowser", result[129].Name);
            Assert.AreEqual("IgnoreImportLibrary", result[130].Name);
            Assert.AreEqual("IncludeBuiltProjectOutputGroup", result[131].Name);
            Assert.AreEqual("IncludeComFilesOutputGroup", result[132].Name);
            Assert.AreEqual("IncludeContentFilesProjectOutputGroup", result[133].Name);
            Assert.AreEqual("IncludeCopyLocalFilesOutputGroup", result[134].Name);
            Assert.AreEqual("IncludeCopyWinMDArtifactsOutputGroup", result[135].Name);
            Assert.AreEqual("IncludeCustomOutputGroupForPackaging", result[136].Name);
            Assert.AreEqual("IncludeDebugSymbolsProjectOutputGroup", result[137].Name);
            Assert.AreEqual("IncludeDocumentationProjectOutputGroup", result[138].Name);
            Assert.AreEqual("IncludeGetResolvedSDKReferences", result[139].Name);
            Assert.AreEqual("IncludePriFilesOutputGroup", result[140].Name);
            Assert.AreEqual("IncludeSatelliteDllsProjectOutputGroup", result[141].Name);
            
            Assert.AreEqual("IncludeSDKRedistOutputGroup", result[142].Name);
            Assert.AreEqual("IncludeSGenFilesOutputGroup", result[143].Name);
            Assert.AreEqual("IncludeSourceFilesProjectOutputGroup", result[144].Name);
            Assert.AreEqual("Install", result[145].Name);
            Assert.AreEqual("InstallFrom", result[146].Name);
            Assert.AreEqual("InstallUrl", result[147].Name);
            Assert.AreEqual("IsWebBootstrapper", result[148].Name);
            Assert.AreEqual("JCPA", result[149].Name);
            Assert.AreEqual("Keyword", result[150].Name);
            Assert.AreEqual("LangVersion", result[151].Name);
            Assert.AreEqual("LinkIncremental", result[152].Name);
            Assert.AreEqual("MakePriExeFullPath", result[153].Name);
            Assert.AreEqual("ManagedWinMDInprocImplementation", result[154].Name);
            Assert.AreEqual("ManifestCertificateThumbprint", result[155].Name);
            Assert.AreEqual("ManifestKeyFile", result[156].Name);
            Assert.AreEqual("MapFileExtensions", result[157].Name);
            Assert.AreEqual("MinimumRequiredVersion", result[158].Name);
            Assert.AreEqual("MyType", result[159].Name);
            Assert.AreEqual("NoConfig", result[160].Name);
            Assert.AreEqual("NoStandardLibraries", result[161].Name);
            Assert.AreEqual("NoStdLib", result[162].Name);
            Assert.AreEqual("NoWarn", result[163].Name);
            Assert.AreEqual("OldToolsVersion", result[164].Name);
            Assert.AreEqual("OpenBrowserOnPublish", result[165].Name);
            Assert.AreEqual("Optimize", result[166].Name);
            Assert.AreEqual("OptionCompare", result[167].Name);
            Assert.AreEqual("OptionExplicit", result[168].Name);
            Assert.AreEqual("OptionInfer", result[169].Name);
            Assert.AreEqual("OptionStrict", result[170].Name);
            Assert.AreEqual("OSVersion", result[171].Name);
            Assert.AreEqual("OutDir", result[172].Name);
            
            Assert.AreEqual("OutputPath", result[173].Name);
            Assert.AreEqual("OutputType", result[174].Name);
            Assert.AreEqual("Platform", result[175].Name);
            Assert.AreEqual("PlatformFamilyName", result[176].Name);
            Assert.AreEqual("PlatformID", result[177].Name);
            Assert.AreEqual("PlatformName", result[178].Name);
            Assert.AreEqual("PlatformTarget", result[179].Name);
            Assert.AreEqual("PlatformToolset", result[180].Name);
            Assert.AreEqual("PostBuildEvent", result[181].Name);
            Assert.AreEqual("PreBuildEvent", result[182].Name);
            Assert.AreEqual("Prefer32Bit", result[183].Name);
            Assert.AreEqual("ProductName", result[184].Name);
            Assert.AreEqual("ProductVersion", result[185].Name);
            Assert.AreEqual("ProjectGuid", result[186].Name);
            Assert.AreEqual("ProjectPriFileName", result[187].Name);
            Assert.AreEqual("ProjectType", result[188].Name);
            Assert.AreEqual("ProjectTypeGuids", result[189].Name);
            Assert.AreEqual("PublisherName", result[190].Name);
            Assert.AreEqual("PublishUrl", result[191].Name);
            Assert.AreEqual("RecursePath", result[192].Name);
            Assert.AreEqual("ReferencePath", result[193].Name);
            Assert.AreEqual("RegisterForComInterop", result[194].Name);
            Assert.AreEqual("RemoteDebugEnabled", result[195].Name);
            Assert.AreEqual("RemoteDebugMachine", result[196].Name);
            Assert.AreEqual("RemoveIntegerChecks", result[197].Name);
            Assert.AreEqual("ResponseFile", result[198].Name);
            Assert.AreEqual("RootNamespace", result[199].Name);
            Assert.AreEqual("RunCodeAnalysis", result[200].Name);
            Assert.AreEqual("RunPostBuildEvent", result[201].Name);
            Assert.AreEqual("SccLocalPath", result[202].Name);
            Assert.AreEqual("SccProjectName", result[203].Name);
            Assert.AreEqual("SccProvider", result[204].Name);
            Assert.AreEqual("SchemaVersion", result[205].Name);
            Assert.AreEqual("SecureScoping", result[206].Name);
            
            Assert.AreEqual("SignAssembly", result[207].Name);
            Assert.AreEqual("SignManifests", result[208].Name);
            Assert.AreEqual("SolutionDir", result[209].Name);
            Assert.AreEqual("SolutionExt", result[210].Name);
            Assert.AreEqual("SolutionFileName", result[211].Name);
            Assert.AreEqual("SolutionName", result[212].Name);
            Assert.AreEqual("SolutionPath", result[213].Name);
            Assert.AreEqual("StartAction", result[214].Name);
            Assert.AreEqual("StartArguments", result[215].Name);
            Assert.AreEqual("StartPage", result[216].Name);
            Assert.AreEqual("StartProgram", result[217].Name);
            Assert.AreEqual("StartupObject", result[218].Name);
            Assert.AreEqual("StartURL", result[219].Name);
            Assert.AreEqual("StartWithIE", result[220].Name);
            Assert.AreEqual("StartWorkingDirectory", result[221].Name);
            Assert.AreEqual("SuiteName", result[222].Name);
            Assert.AreEqual("SupportUrl", result[223].Name);
            Assert.AreEqual("TargetCulture", result[224].Name);
            Assert.AreEqual("TargetExt", result[225].Name);
            Assert.AreEqual("TargetFrameworkProfile", result[226].Name);
            Assert.AreEqual("TargetFrameworkVersion", result[227].Name);
            Assert.AreEqual("TargetName", result[228].Name);
            Assert.AreEqual("TargetPlatformIdentifier", result[229].Name);
            Assert.AreEqual("TargetPlatformVersion", result[230].Name);
            Assert.AreEqual("TargetZone", result[231].Name);
            Assert.AreEqual("TreatWarningsAsErrors", result[232].Name);
            Assert.AreEqual("TrustUrlParameters", result[233].Name);
            Assert.AreEqual("TypeComplianceDiagnostics", result[234].Name);
            Assert.AreEqual("UICulture", result[235].Name);
            Assert.AreEqual("UpdateEnabled", result[236].Name);
            Assert.AreEqual("UpdateInterval", result[237].Name);
            
            Assert.AreEqual("UpdateIntervalUnits", result[238].Name);
            Assert.AreEqual("UpdateMode", result[239].Name);
            Assert.AreEqual("UpdatePeriodically", result[240].Name);
            Assert.AreEqual("UpdateRequired", result[241].Name);
            Assert.AreEqual("UpdateUrl", result[242].Name);
            Assert.AreEqual("UpgradeBackupLocation", result[243].Name);
            Assert.AreEqual("UseAppConfigForCompiler", result[244].Name);
            Assert.AreEqual("UseApplicationTrust", result[245].Name);
            Assert.AreEqual("UseDebugLibraries", result[246].Name);
            Assert.AreEqual("UseIncrementalAppxRegistration", result[247].Name);
            Assert.AreEqual("UseOfAtl", result[248].Name);
            Assert.AreEqual("UseOfMfc", result[249].Name);
            Assert.AreEqual("UseVSHostingProcess", result[250].Name);
            Assert.AreEqual("UTF8OutPut", result[251].Name);
            Assert.AreEqual("VBRuntime", result[252].Name);
            Assert.AreEqual("VCTargetsPath", result[253].Name);
            Assert.AreEqual("VSTO_TrustAssembliesLocation", result[254].Name);
            Assert.AreEqual("WarningLevel", result[255].Name);
            Assert.AreEqual("WarningsAsErrors", result[256].Name);
            Assert.AreEqual("WcfConfigValidationEnabled", result[257].Name);
            Assert.AreEqual("WebPage", result[258].Name);
            Assert.AreEqual("WholeProgramOptimization", result[259].Name);
            Assert.AreEqual("Win32ResourceFile", result[260].Name);
            Assert.AreEqual("WsdlXsdCodeGenCollectionTypes", result[261].Name);
            Assert.AreEqual("WsdlXsdCodeGenEnabled", result[262].Name);
            Assert.AreEqual("WsdlXsdCodeGenEnableDataBinding", result[263].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateAsynchronousOperations", result[264].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateDataTypesOnly", result[265].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateInternalTypes", result[266].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateMessageContract", result[267].Name);
            Assert.AreEqual("WsdlXsdCodeGenGenerateSerializableTypes", result[268].Name);
            Assert.AreEqual("WsdlXsdCodeGenImportXmlTypes", result[269].Name);
            Assert.AreEqual("WsdlXsdCodeGenNamespaceMappings", result[270].Name);
            Assert.AreEqual("WsdlXsdCodeGenReuseTypesFlag", result[271].Name);
            Assert.AreEqual("WsdlXsdCodeGenReuseTypesMode", result[272].Name);
            Assert.AreEqual("WsdlXsdCodeGenSerializerMode", result[273].Name);
            Assert.AreEqual("WsdlXsdCodeGenUseSerializerForFaults", result[274].Name);
            Assert.AreEqual("WsdlXsdCodeGenWrapped", result[275].Name);


            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AllowUnsafeBlocks" });
            Assert.AreEqual(0, result1.Count);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppConfigForCompiler" });
            Assert.AreEqual(0, result2.Count);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppDesignerFolder" });
            Assert.AreEqual(0, result3.Count);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ApplicationIcon" });
            Assert.AreEqual(0, result4.Count);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ApplicationRevision" });
            Assert.AreEqual(0, result5.Count);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ApplicationVersion" });
            Assert.AreEqual(0, result6.Count);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxCreatePriFilesForPortableLibrariesAdditionalMakepriExeParameters" });
            Assert.AreEqual(0, result7.Count);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxDefaultHashUri" });
            Assert.AreEqual(0, result8.Count);
            List<XmlSchemaElement> result9 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxExpandPriContentAdditionalMakepriExeParameters" });
            Assert.AreEqual(0, result9.Count);
            List<XmlSchemaElement> result10 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxGeneratePriEnabled" });
            Assert.AreEqual(0, result10.Count);
            List<XmlSchemaElement> result11 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxGenerateProjectPriFileAdditionalMakepriExeParameters" });
            Assert.AreEqual(0, result11.Count);
            List<XmlSchemaElement> result12 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxHarvestWinMDRegistration" });
            Assert.AreEqual(0, result12.Count);
            List<XmlSchemaElement> result13 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxLayoutDir" });
            Assert.AreEqual(0, result13.Count);
            List<XmlSchemaElement> result14 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxLayoutFolder" });
            Assert.AreEqual(0, result14.Count);
            List<XmlSchemaElement> result15 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxManifestSchema" });
            Assert.AreEqual(0, result15.Count);
            List<XmlSchemaElement> result16 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxMergePriFilesAdditionalMakepriExeParameters" });
            Assert.AreEqual(0, result16.Count);
            List<XmlSchemaElement> result17 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackage" });
            Assert.AreEqual(0, result17.Count);
            List<XmlSchemaElement> result18 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageArtifactsDir" });
            Assert.AreEqual(0, result18.Count);
            List<XmlSchemaElement> result19 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageDir" });
            Assert.AreEqual(0, result19.Count);
            List<XmlSchemaElement> result20 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageName" });
            Assert.AreEqual(0, result20.Count);
            List<XmlSchemaElement> result21 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageOutput" });
            Assert.AreEqual(0, result21.Count);
            List<XmlSchemaElement> result22 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageRecipe" });
            Assert.AreEqual(0, result22.Count);
            List<XmlSchemaElement> result23 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageSigningEnabled" });
            Assert.AreEqual(0, result23.Count);
            List<XmlSchemaElement> result24 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageTestDir" });
            Assert.AreEqual(0, result24.Count);
            List<XmlSchemaElement> result25 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPackageValidationEnabled" });
            Assert.AreEqual(0, result25.Count);
            List<XmlSchemaElement> result26 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPriPrependReswInitialPath" });
            Assert.AreEqual(0, result26.Count);
            List<XmlSchemaElement> result27 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxPriReswInitialPath" });
            Assert.AreEqual(0, result27.Count);
            List<XmlSchemaElement> result28 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxSkipUnchangedFiles" });
            Assert.AreEqual(0, result28.Count);
            List<XmlSchemaElement> result29 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxStoreContainer" });
            Assert.AreEqual(0, result29.Count);
            List<XmlSchemaElement> result30 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxSymbolPackageEnabled" });
            Assert.AreEqual(0, result30.Count);
            List<XmlSchemaElement> result31 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxSymbolPackageOutput" });
            Assert.AreEqual(0, result31.Count);
            List<XmlSchemaElement> result32 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxTestLayoutEnabled" });
            Assert.AreEqual(0, result32.Count);
            List<XmlSchemaElement> result33 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AppxUseHardlinksIfPossible" });
            Assert.AreEqual(0, result33.Count);
            List<XmlSchemaElement> result34 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AspNetConfiguration" });
            Assert.AreEqual(0, result34.Count);
            List<XmlSchemaElement> result35 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AssemblyKeyContainerName" });
            Assert.AreEqual(0, result35.Count);
            List<XmlSchemaElement> result36 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AssemblyKeyProviderName" });
            Assert.AreEqual(0, result36.Count);
            List<XmlSchemaElement> result37 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AssemblyName" });
            Assert.AreEqual(0, result37.Count);
            List<XmlSchemaElement> result38 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AssemblyOriginatorKeyFile" });
            Assert.AreEqual(0, result38.Count);
            List<XmlSchemaElement> result39 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AssemblyOriginatorKeyFileType" });
            Assert.AreEqual(0, result39.Count);
            List<XmlSchemaElement> result40 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AssemblyOriginatorKeyMode" });
            Assert.AreEqual(0, result40.Count);
            List<XmlSchemaElement> result41 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AssemblyType" });
            Assert.AreEqual(0, result41.Count);
            List<XmlSchemaElement> result42 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AutoIncrementPackageRevision" });
            Assert.AreEqual(0, result42.Count);
            List<XmlSchemaElement> result43 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "AutorunEnabled" });
            Assert.AreEqual(0, result43.Count);
            List<XmlSchemaElement> result44 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "BaseAddress" });
            Assert.AreEqual(0, result44.Count);
            List<XmlSchemaElement> result45 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "BootstrapperComponentsLocation" });
            Assert.AreEqual(0, result45.Count);

            List<XmlSchemaElement> result46 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "BootstrapperComponentsUrl" });
            Assert.AreEqual(0, result46.Count);
            List<XmlSchemaElement> result47 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "BootstrapperEnabled" });
            Assert.AreEqual(0, result47.Count);
            List<XmlSchemaElement> result48 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CharacterSet" });
            Assert.AreEqual(0, result48.Count);
            List<XmlSchemaElement> result49 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CheckForOverflowUnderflow" });
            Assert.AreEqual(0, result49.Count);
            List<XmlSchemaElement> result50 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CLRSupport" });
            Assert.AreEqual(0, result50.Count);
            List<XmlSchemaElement> result51 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisAdditionalOptions" });
            Assert.AreEqual(0, result51.Count);
            List<XmlSchemaElement> result52 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisApplyLogFileXsl" });
            Assert.AreEqual(0, result52.Count);
            List<XmlSchemaElement> result53 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisConsoleXsl" });
            Assert.AreEqual(0, result53.Count);
            List<XmlSchemaElement> result54 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisCulture" });
            Assert.AreEqual(0, result54.Count);
            List<XmlSchemaElement> result55 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisFailOnMissingRules" });
            Assert.AreEqual(0, result55.Count);
            List<XmlSchemaElement> result56 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisForceOutput" });
            Assert.AreEqual(0, result56.Count);
            List<XmlSchemaElement> result57 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisGenerateSuccessFile" });
            Assert.AreEqual(0, result57.Count);
            List<XmlSchemaElement> result58 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisIgnoreBuiltInRules" });
            Assert.AreEqual(0, result58.Count);
            List<XmlSchemaElement> result59 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisIgnoreBuiltInRuleSets" });
            Assert.AreEqual(0, result59.Count);
            List<XmlSchemaElement> result60 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisIgnoreGeneratedCode" });
            Assert.AreEqual(0, result60.Count);
            List<XmlSchemaElement> result61 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisIgnoreInvalidTargets" });
            Assert.AreEqual(0, result61.Count);
            List<XmlSchemaElement> result62 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisInputAssembly" });
            Assert.AreEqual(0, result62.Count);
            List<XmlSchemaElement> result63 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisLogFile" });
            Assert.AreEqual(0, result63.Count);
            List<XmlSchemaElement> result64 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisLogFileXsl" });
            Assert.AreEqual(0, result64.Count);
            List<XmlSchemaElement> result65 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisModuleSuppressionsFile" });
            Assert.AreEqual(0, result65.Count);
            List<XmlSchemaElement> result66 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisOutputToConsole" });
            Assert.AreEqual(0, result66.Count);
            List<XmlSchemaElement> result67 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisOverrideRuleVisibilities" });
            Assert.AreEqual(0, result67.Count);

            List<XmlSchemaElement> result68 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisPath" });
            Assert.AreEqual(0, result68.Count);
            List<XmlSchemaElement> result69 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisPlatformPath" });
            Assert.AreEqual(0, result69.Count);
            List<XmlSchemaElement> result70 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisProject" });
            Assert.AreEqual(0, result70.Count);
            List<XmlSchemaElement> result71 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisQuiet" });
            Assert.AreEqual(0, result71.Count);
            List<XmlSchemaElement> result72 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisRuleAssemblies" });
            Assert.AreEqual(0, result72.Count);
            List<XmlSchemaElement> result73 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisRuleDirectories" });
            Assert.AreEqual(0, result73.Count);
            List<XmlSchemaElement> result74 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisRules" });
            Assert.AreEqual(0, result74.Count);
            List<XmlSchemaElement> result75 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisRuleSet" });
            Assert.AreEqual(0, result75.Count);
            List<XmlSchemaElement> result76 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisRuleSetDirectories" });
            Assert.AreEqual(0, result76.Count);
            List<XmlSchemaElement> result77 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisSaveMessagesToReport" });
            Assert.AreEqual(0, result77.Count);
            List<XmlSchemaElement> result78 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisSearchGlobalAssemblyCache" });
            Assert.AreEqual(0, result78.Count);
            List<XmlSchemaElement> result79 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisSummary" });
            Assert.AreEqual(0, result79.Count);
            List<XmlSchemaElement> result80 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisTimeout" });
            Assert.AreEqual(0, result80.Count);
            List<XmlSchemaElement> result81 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisTreatWarningsAsErrors" });
            Assert.AreEqual(0, result81.Count);
            List<XmlSchemaElement> result82 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisUpdateProject" });
            Assert.AreEqual(0, result82.Count);
            List<XmlSchemaElement> result83 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisUseTypeNameInSuppression" });
            Assert.AreEqual(0, result83.Count);
            List<XmlSchemaElement> result84 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodeAnalysisVerbose" });
            Assert.AreEqual(0, result84.Count);
            List<XmlSchemaElement> result85 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CodePage" });
            Assert.AreEqual(0, result85.Count);
            List<XmlSchemaElement> result86 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "Configuration" });
            Assert.AreEqual(0, result86.Count);
            List<XmlSchemaElement> result87 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ConfigurationName" });
            Assert.AreEqual(0, result87.Count);
            List<XmlSchemaElement> result88 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ConfigurationOverrideFile" });
            Assert.AreEqual(0, result88.Count);
            List<XmlSchemaElement> result89 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ConfigurationType" });
            Assert.AreEqual(0, result89.Count);
            List<XmlSchemaElement> result90 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CreateDesktopShortcut" });
            Assert.AreEqual(0, result90.Count);
            List<XmlSchemaElement> result91 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CreateWebPageOnPublish" });
            Assert.AreEqual(0, result91.Count);
            
            List<XmlSchemaElement> result92 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "CurrentSolutionConfigurationContents" });
            Assert.AreEqual(0, result92.Count);
            List<XmlSchemaElement> result93 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DebugSecurityZoneURL" });
            Assert.AreEqual(0, result93.Count);
            List<XmlSchemaElement> result94 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DebugSymbols" });
            Assert.AreEqual(0, result94.Count);
            List<XmlSchemaElement> result95 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DebugType" });
            Assert.AreEqual(0, result95.Count);
            List<XmlSchemaElement> result96 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DefaultClientScript" });
            Assert.AreEqual(0, result96.Count);
            List<XmlSchemaElement> result97 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DefaultHTMLPageLayout" });
            Assert.AreEqual(0, result97.Count);
            List<XmlSchemaElement> result98 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DefaultTargetSchema" });
            Assert.AreEqual(0, result98.Count);
            List<XmlSchemaElement> result99 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DefineConstants" });
            Assert.AreEqual(0, result99.Count);
            List<XmlSchemaElement> result100 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DefineDebug" });
            Assert.AreEqual(0, result100.Count);
            List<XmlSchemaElement> result101 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DefineTrace" });
            Assert.AreEqual(0, result101.Count);
            List<XmlSchemaElement> result102 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DelaySign" });
            Assert.AreEqual(0, result102.Count);
            List<XmlSchemaElement> result103 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DeployDirSuffix" });
            Assert.AreEqual(0, result103.Count);
            List<XmlSchemaElement> result104 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DisableFastUpToDateCheck" });
            Assert.AreEqual(0, result104.Count);
            List<XmlSchemaElement> result105 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DisableLangXtns" });
            Assert.AreEqual(0, result105.Count);
            List<XmlSchemaElement> result106 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DisallowUrlActivation" });
            Assert.AreEqual(0, result106.Count);
            List<XmlSchemaElement> result107 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "DocumentationFile" });
            Assert.AreEqual(0, result107.Count);
            List<XmlSchemaElement> result108 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "EmbedManifest" });
            Assert.AreEqual(0, result108.Count);
            List<XmlSchemaElement> result109 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "EnableASPDebugging" });
            Assert.AreEqual(0, result109.Count);
            List<XmlSchemaElement> result110 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "EnableASPXDebugging" });
            Assert.AreEqual(0, result110.Count);
            List<XmlSchemaElement> result111 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "EnableSecurityDebugging" });
            Assert.AreEqual(0, result111.Count);
            List<XmlSchemaElement> result112 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "EnableSQLServerDebugging" });
            Assert.AreEqual(0, result112.Count);
            List<XmlSchemaElement> result113 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "EnableUnmanagedDebugging" });
            Assert.AreEqual(0, result113.Count);
            List<XmlSchemaElement> result114 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ErrorReport" });
            Assert.AreEqual(0, result114.Count);
            List<XmlSchemaElement> result115 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ErrorReportUrl" });
            Assert.AreEqual(0, result115.Count);
            List<XmlSchemaElement> result116 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ExcludeDeploymentUrl" });
            Assert.AreEqual(0, result116.Count);
            
            List<XmlSchemaElement> result117 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ExcludedPermissions" });
            Assert.AreEqual(0, result117.Count);
            List<XmlSchemaElement> result118 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FallbackCulture" });
            Assert.AreEqual(0, result118.Count);
            List<XmlSchemaElement> result119 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FileAlignment" });
            Assert.AreEqual(0, result119.Count);
            List<XmlSchemaElement> result120 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FileUpgradeFlags" });
            Assert.AreEqual(0, result120.Count);
            List<XmlSchemaElement> result121 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FinalAppxManifestName" });
            Assert.AreEqual(0, result121.Count);
            List<XmlSchemaElement> result122 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FinalAppxPackageRecipe" });
            Assert.AreEqual(0, result122.Count);
            List<XmlSchemaElement> result123 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FinalPriFileName" });
            Assert.AreEqual(0, result123.Count);
            List<XmlSchemaElement> result124 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FinalPriFullPath" });
            Assert.AreEqual(0, result124.Count);
            List<XmlSchemaElement> result125 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FormFactorID" });
            Assert.AreEqual(0, result125.Count);
            List<XmlSchemaElement> result126 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "FrameworkPathOverride" });
            Assert.AreEqual(0, result126.Count);
            List<XmlSchemaElement> result127 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "GenerateManifests" });
            Assert.AreEqual(0, result127.Count);
            List<XmlSchemaElement> result128 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "GenerateSerializationAssemblies" });
            Assert.AreEqual(0, result128.Count);
            List<XmlSchemaElement> result129 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "HighEntropyVA" });
            Assert.AreEqual(0, result129.Count);
            List<XmlSchemaElement> result130 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "HostInBrowser" });
            Assert.AreEqual(0, result130.Count);
            List<XmlSchemaElement> result131 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IgnoreImportLibrary" });
            Assert.AreEqual(0, result131.Count);
            List<XmlSchemaElement> result132 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeBuiltProjectOutputGroup" });
            Assert.AreEqual(0, result132.Count);
            List<XmlSchemaElement> result133 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeComFilesOutputGroup" });
            Assert.AreEqual(0, result133.Count);
            List<XmlSchemaElement> result134 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeContentFilesProjectOutputGroup" });
            Assert.AreEqual(0, result134.Count);
            List<XmlSchemaElement> result135 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeCopyLocalFilesOutputGroup" });
            Assert.AreEqual(0, result135.Count);
            List<XmlSchemaElement> result136 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeCopyWinMDArtifactsOutputGroup" });
            Assert.AreEqual(0, result136.Count);
            List<XmlSchemaElement> result137 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeCustomOutputGroupForPackaging" });
            Assert.AreEqual(0, result137.Count);
            List<XmlSchemaElement> result138 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeDebugSymbolsProjectOutputGroup" });
            Assert.AreEqual(0, result138.Count);
            List<XmlSchemaElement> result139 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeDocumentationProjectOutputGroup" });
            Assert.AreEqual(0, result139.Count);
            List<XmlSchemaElement> result140 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeGetResolvedSDKReferences" });
            Assert.AreEqual(0, result140.Count);
            List<XmlSchemaElement> result141 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludePriFilesOutputGroup" });
            Assert.AreEqual(0, result141.Count);
            List<XmlSchemaElement> result142 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeSatelliteDllsProjectOutputGroup" });
            Assert.AreEqual(0, result142.Count);
            
            List<XmlSchemaElement> result143 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeSDKRedistOutputGroup" });
            Assert.AreEqual(0, result143.Count);
            List<XmlSchemaElement> result144 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeSGenFilesOutputGroup" });
            Assert.AreEqual(0, result144.Count);
            List<XmlSchemaElement> result145 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IncludeSourceFilesProjectOutputGroup" });
            Assert.AreEqual(0, result145.Count);
            List<XmlSchemaElement> result146 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "Install" });
            Assert.AreEqual(0, result146.Count);
            List<XmlSchemaElement> result147 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "InstallFrom" });
            Assert.AreEqual(0, result147.Count);
            List<XmlSchemaElement> result148 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "InstallUrl" });
            Assert.AreEqual(0, result148.Count);
            List<XmlSchemaElement> result149 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "IsWebBootstrapper" });
            Assert.AreEqual(0, result149.Count);
            List<XmlSchemaElement> result150 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "JCPA" });
            Assert.AreEqual(0, result150.Count);
            List<XmlSchemaElement> result151 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "Keyword" });
            Assert.AreEqual(0, result151.Count);
            List<XmlSchemaElement> result152 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "LangVersion" });
            Assert.AreEqual(0, result152.Count);
            List<XmlSchemaElement> result153 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "LinkIncremental" });
            Assert.AreEqual(0, result153.Count);
            List<XmlSchemaElement> result154 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "MakePriExeFullPath" });
            Assert.AreEqual(0, result154.Count);
            List<XmlSchemaElement> result155 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ManagedWinMDInprocImplementation" });
            Assert.AreEqual(0, result155.Count);
            List<XmlSchemaElement> result156 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ManifestCertificateThumbprint" });
            Assert.AreEqual(0, result156.Count);
            List<XmlSchemaElement> result157 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ManifestKeyFile" });
            Assert.AreEqual(0, result157.Count);
            List<XmlSchemaElement> result158 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "MapFileExtensions" });
            Assert.AreEqual(0, result158.Count);
            List<XmlSchemaElement> result159 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "MinimumRequiredVersion" });
            Assert.AreEqual(0, result159.Count);
            List<XmlSchemaElement> result160 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "MyType" });
            Assert.AreEqual(0, result160.Count);
            List<XmlSchemaElement> result161 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "NoConfig" });
            Assert.AreEqual(0, result161.Count);
            List<XmlSchemaElement> result162 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "NoStandardLibraries" });
            Assert.AreEqual(0, result162.Count);
            List<XmlSchemaElement> result163 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "NoStdLib" });
            Assert.AreEqual(0, result163.Count);
            List<XmlSchemaElement> result164 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "NoWarn" });
            Assert.AreEqual(0, result164.Count);
            List<XmlSchemaElement> result165 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OldToolsVersion" });
            Assert.AreEqual(0, result165.Count);
            List<XmlSchemaElement> result166 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OpenBrowserOnPublish" });
            Assert.AreEqual(0, result166.Count);
            List<XmlSchemaElement> result167 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "Optimize" });
            Assert.AreEqual(0, result167.Count);
            List<XmlSchemaElement> result168 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OptionCompare" });
            Assert.AreEqual(0, result168.Count);
            List<XmlSchemaElement> result169 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OptionExplicit" });
            Assert.AreEqual(0, result169.Count);
            List<XmlSchemaElement> result170 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OptionInfer" });
            Assert.AreEqual(0, result170.Count);
            List<XmlSchemaElement> result171 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OptionStrict" });
            Assert.AreEqual(0, result171.Count);
            List<XmlSchemaElement> result172 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OSVersion" });
            Assert.AreEqual(0, result172.Count);
            List<XmlSchemaElement> result173 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OutDir" });
            Assert.AreEqual(0, result173.Count);
            
            List<XmlSchemaElement> result174 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OutputPath" });
            Assert.AreEqual(0, result174.Count);
            List<XmlSchemaElement> result175 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "OutputType" });
            Assert.AreEqual(0, result175.Count);
            List<XmlSchemaElement> result176 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "Platform" });
            Assert.AreEqual(0, result176.Count);
            List<XmlSchemaElement> result177 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PlatformFamilyName" });
            Assert.AreEqual(0, result177.Count);
            List<XmlSchemaElement> result178 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PlatformID" });
            Assert.AreEqual(0, result178.Count);
            List<XmlSchemaElement> result179 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PlatformName" });
            Assert.AreEqual(0, result179.Count);
            List<XmlSchemaElement> result180 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PlatformTarget" });
            Assert.AreEqual(0, result180.Count);
            List<XmlSchemaElement> result181 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PlatformToolset" });
            Assert.AreEqual(0, result181.Count);
            List<XmlSchemaElement> result182 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PostBuildEvent" });
            Assert.AreEqual(0, result182.Count);
            List<XmlSchemaElement> result183 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PreBuildEvent" });
            Assert.AreEqual(0, result183.Count);
            List<XmlSchemaElement> result184 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "Prefer32Bit" });
            Assert.AreEqual(0, result184.Count);
            List<XmlSchemaElement> result185 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ProductName" });
            Assert.AreEqual(0, result185.Count);
            List<XmlSchemaElement> result186 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ProductVersion" });
            Assert.AreEqual(0, result186.Count);
            List<XmlSchemaElement> result188 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ProjectGuid" });
            Assert.AreEqual(0, result188.Count);
            List<XmlSchemaElement> result189 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ProjectPriFileName" });
            Assert.AreEqual(0, result189.Count);
            List<XmlSchemaElement> result190 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ProjectType" });
            Assert.AreEqual(0, result190.Count);
            List<XmlSchemaElement> result191 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ProjectTypeGuids" });
            Assert.AreEqual(0, result191.Count);
            List<XmlSchemaElement> result192 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PublisherName" });
            Assert.AreEqual(0, result192.Count);
            List<XmlSchemaElement> result193 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "PublishUrl" });
            Assert.AreEqual(0, result193.Count);
            List<XmlSchemaElement> result194 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RecursePath" });
            Assert.AreEqual(0, result194.Count);
            List<XmlSchemaElement> result195 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ReferencePath" });
            Assert.AreEqual(0, result195.Count);
            List<XmlSchemaElement> result196 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RegisterForComInterop" });
            Assert.AreEqual(0, result196.Count);
            List<XmlSchemaElement> result197 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RemoteDebugEnabled" });
            Assert.AreEqual(0, result197.Count);
            List<XmlSchemaElement> result198 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RemoteDebugMachine" });
            Assert.AreEqual(0, result198.Count);
            List<XmlSchemaElement> result199 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RemoveIntegerChecks" });
            Assert.AreEqual(0, result199.Count);
            List<XmlSchemaElement> result200 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "ResponseFile" });
            Assert.AreEqual(0, result200.Count);
            List<XmlSchemaElement> result201 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RootNamespace" });
            Assert.AreEqual(0, result201.Count);
            List<XmlSchemaElement> result202 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RunCodeAnalysis" });
            Assert.AreEqual(0, result202.Count);
            List<XmlSchemaElement> result203 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "RunPostBuildEvent" });
            Assert.AreEqual(0, result203.Count);
            List<XmlSchemaElement> result204 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SccLocalPath" });
            Assert.AreEqual(0, result204.Count);
            List<XmlSchemaElement> result205 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SccProjectName" });
            Assert.AreEqual(0, result205.Count);
            List<XmlSchemaElement> result206 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SccProvider" });
            Assert.AreEqual(0, result206.Count);
            List<XmlSchemaElement> result207 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SchemaVersion" });
            Assert.AreEqual(0, result207.Count);
            List<XmlSchemaElement> result208 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SecureScoping" });
            Assert.AreEqual(0, result208.Count);
            
            List<XmlSchemaElement> result209 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SignAssembly" });
            Assert.AreEqual(0, result209.Count);
            List<XmlSchemaElement> result210 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SignManifests" });
            Assert.AreEqual(0, result210.Count);
            List<XmlSchemaElement> result211 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SolutionDir" });
            Assert.AreEqual(0, result211.Count);
            List<XmlSchemaElement> result212 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SolutionExt" });
            Assert.AreEqual(0, result212.Count);
            List<XmlSchemaElement> result213 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SolutionFileName" });
            Assert.AreEqual(0, result213.Count);
            List<XmlSchemaElement> result214 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SolutionName" });
            Assert.AreEqual(0, result214.Count);
            List<XmlSchemaElement> result215 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SolutionPath" });
            Assert.AreEqual(0, result215.Count);
            List<XmlSchemaElement> result216 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartAction" });
            Assert.AreEqual(0, result216.Count);
            List<XmlSchemaElement> result217 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartArguments" });
            Assert.AreEqual(0, result217.Count);
            List<XmlSchemaElement> result218 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartPage" });
            Assert.AreEqual(0, result218.Count);
            List<XmlSchemaElement> result219 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartProgram" });
            Assert.AreEqual(0, result219.Count);
            List<XmlSchemaElement> result220 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartupObject" });
            Assert.AreEqual(0, result220.Count);
            List<XmlSchemaElement> result221 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartURL" });
            Assert.AreEqual(0, result221.Count);
            List<XmlSchemaElement> result222 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartWithIE" });
            Assert.AreEqual(0, result222.Count);
            List<XmlSchemaElement> result223 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "StartWorkingDirectory" });
            Assert.AreEqual(0, result223.Count);
            List<XmlSchemaElement> result224 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SuiteName" });
            Assert.AreEqual(0, result224.Count);
            List<XmlSchemaElement> result225 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "SupportUrl" });
            Assert.AreEqual(0, result225.Count);
            List<XmlSchemaElement> result226 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetCulture" });
            Assert.AreEqual(0, result226.Count);
            List<XmlSchemaElement> result227 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetExt" });
            Assert.AreEqual(0, result227.Count);
            List<XmlSchemaElement> result228 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetFrameworkProfile" });
            Assert.AreEqual(0, result228.Count);
            List<XmlSchemaElement> result229 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetFrameworkVersion" });
            Assert.AreEqual(0, result229.Count);
            List<XmlSchemaElement> result230 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetName" });
            Assert.AreEqual(0, result230.Count);
            List<XmlSchemaElement> result231 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetPlatformIdentifier" });
            Assert.AreEqual(0, result231.Count);
            List<XmlSchemaElement> result232 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetPlatformVersion" });
            Assert.AreEqual(0, result232.Count);
            List<XmlSchemaElement> result233 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TargetZone" });
            Assert.AreEqual(0, result233.Count);
            List<XmlSchemaElement> result234 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TreatWarningsAsErrors" });
            Assert.AreEqual(0, result234.Count);
            List<XmlSchemaElement> result235 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TrustUrlParameters" });
            Assert.AreEqual(0, result235.Count);
            List<XmlSchemaElement> result236 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "TypeComplianceDiagnostics" });
            Assert.AreEqual(0, result236.Count);
            List<XmlSchemaElement> result237 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UICulture" });
            Assert.AreEqual(0, result237.Count);
            List<XmlSchemaElement> result238 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpdateEnabled" });
            Assert.AreEqual(0, result238.Count);
            List<XmlSchemaElement> result239 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpdateInterval" });
            Assert.AreEqual(0, result239.Count);
            List<XmlSchemaElement> result240 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpdateIntervalUnits" });
            Assert.AreEqual(0, result240.Count);
            List<XmlSchemaElement> result241 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpdateMode" });
            Assert.AreEqual(0, result241.Count);
            List<XmlSchemaElement> result242 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpdatePeriodically" });
            Assert.AreEqual(0, result242.Count);
            List<XmlSchemaElement> result243 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpdateRequired" });
            Assert.AreEqual(0, result243.Count);
            List<XmlSchemaElement> result244 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpdateUrl" });
            Assert.AreEqual(0, result244.Count);
            List<XmlSchemaElement> result245 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UpgradeBackupLocation" });
            Assert.AreEqual(0, result245.Count);
            List<XmlSchemaElement> result246 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UseAppConfigForCompiler" });
            Assert.AreEqual(0, result246.Count);
            List<XmlSchemaElement> result247 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UseApplicationTrust" });
            Assert.AreEqual(0, result247.Count);
            List<XmlSchemaElement> result248 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UseDebugLibraries" });
            Assert.AreEqual(0, result248.Count);
            List<XmlSchemaElement> result249 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UseIncrementalAppxRegistration" });
            Assert.AreEqual(0, result249.Count);
            List<XmlSchemaElement> result250 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UseOfAtl" });
            Assert.AreEqual(0, result250.Count);
            List<XmlSchemaElement> result251 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UseOfMfc" });
            Assert.AreEqual(0, result251.Count);
            List<XmlSchemaElement> result252 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UseVSHostingProcess" });
            Assert.AreEqual(0, result252.Count);
            List<XmlSchemaElement> result253 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "UTF8OutPut" });
            Assert.AreEqual(0, result253.Count);
            List<XmlSchemaElement> result254 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "VBRuntime" });
            Assert.AreEqual(0, result254.Count);
            List<XmlSchemaElement> result255 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "VCTargetsPath" });
            Assert.AreEqual(0, result255.Count);
            List<XmlSchemaElement> result256 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "VSTO_TrustAssembliesLocation" });
            Assert.AreEqual(0, result256.Count);
            List<XmlSchemaElement> result257 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WarningLevel" });
            Assert.AreEqual(0, result257.Count);
            List<XmlSchemaElement> result258 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WarningsAsErrors" });
            Assert.AreEqual(0, result258.Count);
            List<XmlSchemaElement> result259 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WcfConfigValidationEnabled" });
            Assert.AreEqual(0, result259.Count);
            List<XmlSchemaElement> result260 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WebPage" });
            Assert.AreEqual(0, result260.Count);
            List<XmlSchemaElement> result261 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WholeProgramOptimization" });
            Assert.AreEqual(0, result261.Count);
            List<XmlSchemaElement> result262 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "Win32ResourceFile" });
            Assert.AreEqual(0, result262.Count);
            List<XmlSchemaElement> result263 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenCollectionTypes" });
            Assert.AreEqual(0, result263.Count);
            List<XmlSchemaElement> result264 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenEnabled" });
            Assert.AreEqual(0, result264.Count);
            List<XmlSchemaElement> result265 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenEnableDataBinding" });
            Assert.AreEqual(0, result265.Count);
            List<XmlSchemaElement> result266 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenGenerateAsynchronousOperations" });
            Assert.AreEqual(0, result266.Count);
            List<XmlSchemaElement> result267 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenGenerateDataTypesOnly" });
            Assert.AreEqual(0, result267.Count);
            List<XmlSchemaElement> result268 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenGenerateInternalTypes" });
            Assert.AreEqual(0, result268.Count);
            List<XmlSchemaElement> result269 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenGenerateMessageContract" });
            Assert.AreEqual(0, result269.Count);
            List<XmlSchemaElement> result270 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenGenerateSerializableTypes" });
            Assert.AreEqual(0, result270.Count);
            List<XmlSchemaElement> result271 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenImportXmlTypes" });
            Assert.AreEqual(0, result271.Count);
            List<XmlSchemaElement> result272 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenNamespaceMappings" });
            Assert.AreEqual(0, result272.Count);
            List<XmlSchemaElement> result273 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenReuseTypesFlag" });
            Assert.AreEqual(0, result273.Count);
            List<XmlSchemaElement> result274 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenReuseTypesMode" });
            Assert.AreEqual(0, result274.Count);
            List<XmlSchemaElement> result275 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenSerializerMode" });
            Assert.AreEqual(0, result275.Count);
            List<XmlSchemaElement> result276 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenUseSerializerForFaults" });
            Assert.AreEqual(0, result276.Count);
            List<XmlSchemaElement> result277 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "PropertyGroup", "WsdlXsdCodeGenWrapped" });
            Assert.AreEqual(0, result277.Count);

        }
        #endregion

        #region /Project/Target
        /// <summary>
        /// /Project/Target
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod224()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "Target" });
            Assert.AreEqual(102, result.Count);
            
            //AL
            Assert.AreEqual("AL", result[0].Name);
            List<XmlSchemaElement> result1 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AL" });
            Assert.AreEqual(1, result1.Count);
            Assert.AreEqual("Output", result1[0].Name);
            List<XmlSchemaElement> result1a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AL","Output" });
            Assert.AreEqual(0, result1a.Count);
            
            //AspNetCompiler
            Assert.AreEqual("AspNetCompiler", result[1].Name);
            List<XmlSchemaElement> result2 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AspNetCompiler" });
            Assert.AreEqual(1, result2.Count);
            Assert.AreEqual("Output", result2[0].Name);
            List<XmlSchemaElement> result2a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AspNetCompiler", "Output" });
            Assert.AreEqual(0, result2a.Count);
            
            //AssignCulture
            Assert.AreEqual("AssignCulture", result[2].Name);
            List<XmlSchemaElement> result3 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AssignCulture" });
            Assert.AreEqual(1, result3.Count);
            Assert.AreEqual("Output", result3[0].Name);
            List<XmlSchemaElement> result3a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AssignCulture", "Output" });
            Assert.AreEqual(0, result3a.Count);

            //AssignProjectConfiguration
            Assert.AreEqual("AssignProjectConfiguration", result[3].Name);
            List<XmlSchemaElement> result4 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AssignProjectConfiguration" });
            Assert.AreEqual(1, result4.Count);
            Assert.AreEqual("Output", result4[0].Name);
            List<XmlSchemaElement> result4a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AssignProjectConfiguration", "Output" });
            Assert.AreEqual(0, result4a.Count);

            //AssignTargetPath
            Assert.AreEqual("AssignTargetPath", result[4].Name);
            List<XmlSchemaElement> result5 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AssignTargetPath" });
            Assert.AreEqual(1, result5.Count);
            Assert.AreEqual("Output", result5[0].Name);
            List<XmlSchemaElement> result5a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AssignTargetPath", "Output" });
            Assert.AreEqual(0, result5a.Count);

            //AxImp
            Assert.AreEqual("AxImp", result[5].Name);
            List<XmlSchemaElement> result6 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AxImp" });
            Assert.AreEqual(1, result6.Count);
            Assert.AreEqual("Output", result6[0].Name);
            List<XmlSchemaElement> result6a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "AxImp", "Output" });
            Assert.AreEqual(0, result6a.Count);

            //BSCMake
            Assert.AreEqual("BSCMake", result[6].Name);
            List<XmlSchemaElement> result7 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "BSCMake" });
            Assert.AreEqual(1, result7.Count);
            Assert.AreEqual("Output", result7[0].Name);
            List<XmlSchemaElement> result7a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "BSCMake", "Output" });
            Assert.AreEqual(0, result7a.Count);

            //CallTarget
            Assert.AreEqual("CallTarget", result[7].Name);
            List<XmlSchemaElement> result8 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CallTarget" });
            Assert.AreEqual(1, result8.Count);
            Assert.AreEqual("Output", result8[0].Name);
            List<XmlSchemaElement> result8a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CallTarget", "Output" });
            Assert.AreEqual(0, result8a.Count);

            //CL
            Assert.AreEqual("CL", result[8].Name);
            List<XmlSchemaElement> result9 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CL" });
            Assert.AreEqual(1, result9.Count);
            Assert.AreEqual("Output", result9[0].Name);
            List<XmlSchemaElement> result9a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CL", "Output" });
            Assert.AreEqual(0, result9a.Count);

            //CodeAnalysis
            Assert.AreEqual("CodeAnalysis", result[9].Name);
            List<XmlSchemaElement> result10 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CodeAnalysis" });
            Assert.AreEqual(1, result10.Count);
            Assert.AreEqual("Output", result10[0].Name);
            List<XmlSchemaElement> result10a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CodeAnalysis", "Output" });
            Assert.AreEqual(0, result10a.Count);

            //CombinePath
            Assert.AreEqual("CombinePath", result[10].Name);
            List<XmlSchemaElement> result11 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CombinePath" });
            Assert.AreEqual(1, result11.Count);
            Assert.AreEqual("Output", result11[0].Name);
            List<XmlSchemaElement> result11a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CombinePath", "Output" });
            Assert.AreEqual(0, result11a.Count);

            //ConvertToAbsolutePath
            Assert.AreEqual("ConvertToAbsolutePath", result[11].Name);
            List<XmlSchemaElement> result12 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ConvertToAbsolutePath" });
            Assert.AreEqual(1, result12.Count);
            Assert.AreEqual("Output", result12[0].Name);
            List<XmlSchemaElement> result12a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ConvertToAbsolutePath", "Output" });
            Assert.AreEqual(0, result12a.Count);

            //Copy
            Assert.AreEqual("Copy", result[12].Name);
            List<XmlSchemaElement> result13 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Copy" });
            Assert.AreEqual(1, result13.Count);
            Assert.AreEqual("Output", result13[0].Name);
            List<XmlSchemaElement> result13a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Copy", "Output" });
            Assert.AreEqual(0, result13a.Count);

            //CPPClean
            Assert.AreEqual("CPPClean", result[13].Name);
            List<XmlSchemaElement> result14 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CPPClean" });
            Assert.AreEqual(1, result14.Count);
            Assert.AreEqual("Output", result14[0].Name);
            List<XmlSchemaElement> result14a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CPPClean", "Output" });
            Assert.AreEqual(0, result14a.Count);

            //CreateAppStoreContainer
            Assert.AreEqual("CreateAppStoreContainer", result[14].Name);
            List<XmlSchemaElement> result15 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateAppStoreContainer" });
            Assert.AreEqual(1, result15.Count);
            Assert.AreEqual("Output", result15[0].Name);
            List<XmlSchemaElement> result15a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateAppStoreContainer", "Output" });
            Assert.AreEqual(0, result15a.Count);

            //CreateAppxLayout
            Assert.AreEqual("CreateAppxLayout", result[15].Name);
            List<XmlSchemaElement> result16 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateAppxLayout" });
            Assert.AreEqual(1, result16.Count);
            Assert.AreEqual("Output", result16[0].Name);
            List<XmlSchemaElement> result16a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateAppxLayout", "Output" });
            Assert.AreEqual(0, result16a.Count);

            //CreateCSharpManifestResourceName
            Assert.AreEqual("CreateCSharpManifestResourceName", result[16].Name);
            List<XmlSchemaElement> result17 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateCSharpManifestResourceName" });
            Assert.AreEqual(1, result17.Count);
            Assert.AreEqual("Output", result17[0].Name);
            List<XmlSchemaElement> result17a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateCSharpManifestResourceName", "Output" });
            Assert.AreEqual(0, result17a.Count);

            //CreateItem
            Assert.AreEqual("CreateItem", result[17].Name);
            List<XmlSchemaElement> result18 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateItem" });
            Assert.AreEqual(1, result18.Count);
            Assert.AreEqual("Output", result18[0].Name);
            List<XmlSchemaElement> result18a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateItem", "Output" });
            Assert.AreEqual(0, result18a.Count);

            //CreateProperty
            Assert.AreEqual("CreateProperty", result[18].Name);
            List<XmlSchemaElement> result19 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateProperty" });
            Assert.AreEqual(1, result19.Count);
            Assert.AreEqual("Output", result19[0].Name);
            List<XmlSchemaElement> result19a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateProperty", "Output" });
            Assert.AreEqual(0, result19a.Count);

            //CreateVisualBasicManifestResourceName
            Assert.AreEqual("CreateVisualBasicManifestResourceName", result[19].Name);
            List<XmlSchemaElement> result20 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateVisualBasicManifestResourceName" });
            Assert.AreEqual(1, result20.Count);
            Assert.AreEqual("Output", result20[0].Name);
            List<XmlSchemaElement> result20a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "CreateVisualBasicManifestResourceName", "Output" });
            Assert.AreEqual(0, result20a.Count);

            //Csc
            Assert.AreEqual("Csc", result[20].Name);
            List<XmlSchemaElement> result21 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Csc" });
            Assert.AreEqual(1, result21.Count);
            Assert.AreEqual("Output", result21[0].Name);
            List<XmlSchemaElement> result21a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Csc", "Output" });
            Assert.AreEqual(0, result21a.Count);

            //Delete
            Assert.AreEqual("Delete", result[21].Name);
            List<XmlSchemaElement> result22 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Delete" });
            Assert.AreEqual(1, result22.Count);
            Assert.AreEqual("Output", result22[0].Name);
            List<XmlSchemaElement> result22a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Delete", "Output" });
            Assert.AreEqual(0, result22a.Count);

            //Error
            Assert.AreEqual("Error", result[22].Name);
            List<XmlSchemaElement> result23 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Error" });
            Assert.AreEqual(1, result23.Count);
            Assert.AreEqual("Output", result23[0].Name);
            List<XmlSchemaElement> result23a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Error", "Output" });
            Assert.AreEqual(0, result23a.Count);

            //Exec
            Assert.AreEqual("Exec", result[23].Name);
            List<XmlSchemaElement> result24 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Exec" });
            Assert.AreEqual(1, result24.Count);
            Assert.AreEqual("Output", result24[0].Name);
            List<XmlSchemaElement> result24a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Exec", "Output" });
            Assert.AreEqual(0, result24a.Count);

            //ExpandPayloadDirectories
            Assert.AreEqual("ExpandPayloadDirectories", result[24].Name);
            List<XmlSchemaElement> result25 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExpandPayloadDirectories" });
            Assert.AreEqual(1, result25.Count);
            Assert.AreEqual("Output", result25[0].Name);
            List<XmlSchemaElement> result25a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExpandPayloadDirectories", "Output" });
            Assert.AreEqual(0, result25a.Count);

            //ExpandPriContent
            Assert.AreEqual("ExpandPriContent", result[25].Name);
            List<XmlSchemaElement> result26 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExpandPriContent" });
            Assert.AreEqual(1, result26.Count);
            Assert.AreEqual("Output", result26[0].Name);
            List<XmlSchemaElement> result26a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExpandPriContent", "Output" });
            Assert.AreEqual(0, result26a.Count);

            //ExtractHashUri
            Assert.AreEqual("ExtractHashUri", result[26].Name);
            List<XmlSchemaElement> result27 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExtractHashUri" });
            Assert.AreEqual(1, result27.Count);
            Assert.AreEqual("Output", result27[0].Name);
            List<XmlSchemaElement> result27a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExtractHashUri", "Output" });
            Assert.AreEqual(0, result27a.Count);

            //ExtractPriLanguages
            Assert.AreEqual("ExtractPriLanguages", result[27].Name);
            List<XmlSchemaElement> result28 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExtractPriLanguages" });
            Assert.AreEqual(1, result28.Count);
            Assert.AreEqual("Output", result28[0].Name);
            List<XmlSchemaElement> result28a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ExtractPriLanguages", "Output" });
            Assert.AreEqual(0, result28a.Count);

            //FindAppConfigFile
            Assert.AreEqual("FindAppConfigFile", result[28].Name);
            List<XmlSchemaElement> result29 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FindAppConfigFile" });
            Assert.AreEqual(1, result29.Count);
            Assert.AreEqual("Output", result29[0].Name);
            List<XmlSchemaElement> result29a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FindAppConfigFile", "Output" });
            Assert.AreEqual(0, result29a.Count);

            //FindInList
            Assert.AreEqual("FindInList", result[29].Name);
            List<XmlSchemaElement> result30 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FindInList" });
            Assert.AreEqual(1, result30.Count);
            Assert.AreEqual("Output", result30[0].Name);
            List<XmlSchemaElement> result30a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FindInList", "Output" });
            Assert.AreEqual(0, result30a.Count);

            //FindUnderPath
            Assert.AreEqual("FindUnderPath", result[30].Name);
            List<XmlSchemaElement> result31 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FindUnderPath" });
            Assert.AreEqual(1, result31.Count);
            Assert.AreEqual("Output", result31[0].Name);
            List<XmlSchemaElement> result31a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FindUnderPath", "Output" });
            Assert.AreEqual(0, result31a.Count);

            //FormatUrl
            Assert.AreEqual("FormatUrl", result[31].Name);
            List<XmlSchemaElement> result32 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FormatUrl" });
            Assert.AreEqual(1, result32.Count);
            Assert.AreEqual("Output", result32[0].Name);
            List<XmlSchemaElement> result32a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FormatUrl", "Output" });
            Assert.AreEqual(0, result32a.Count);

            //FormatVersion
            Assert.AreEqual("FormatVersion", result[32].Name);
            List<XmlSchemaElement> result33 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FormatVersion" });
            Assert.AreEqual(1, result33.Count);
            Assert.AreEqual("Output", result33[0].Name);
            List<XmlSchemaElement> result33a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "FormatVersion", "Output" });
            Assert.AreEqual(0, result33a.Count);

            //GenerateApplicationManifest
            Assert.AreEqual("GenerateApplicationManifest", result[33].Name);
            List<XmlSchemaElement> result34 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateApplicationManifest" });
            Assert.AreEqual(1, result34.Count);
            Assert.AreEqual("Output", result34[0].Name);
            List<XmlSchemaElement> result34a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateApplicationManifest", "Output" });
            Assert.AreEqual(0, result34a.Count);

            //GenerateAppxManifest
            Assert.AreEqual("GenerateAppxManifest", result[34].Name);
            List<XmlSchemaElement> result35 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxManifest" });
            Assert.AreEqual(1, result35.Count);
            Assert.AreEqual("Output", result35[0].Name);
            List<XmlSchemaElement> result35a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxManifest", "Output" });
            Assert.AreEqual(0, result35a.Count);

            //GenerateAppxPackage
            Assert.AreEqual("GenerateAppxPackage", result[35].Name);
            List<XmlSchemaElement> result36 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxPackage" });
            Assert.AreEqual(1, result36.Count);
            Assert.AreEqual("Output", result36[0].Name);
            List<XmlSchemaElement> result36a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxPackage", "Output" });
            Assert.AreEqual(0, result36a.Count);

            //GenerateAppxPackageRecipe
            Assert.AreEqual("GenerateAppxPackageRecipe", result[36].Name);
            List<XmlSchemaElement> result37 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxPackageRecipe" });
            Assert.AreEqual(1, result37.Count);
            Assert.AreEqual("Output", result37[0].Name);
            List<XmlSchemaElement> result37a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxPackageRecipe", "Output" });
            Assert.AreEqual(0, result37a.Count);

            //GenerateAppxSymbolPackage
            Assert.AreEqual("GenerateAppxSymbolPackage", result[37].Name);
            List<XmlSchemaElement> result38 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxSymbolPackage" });
            Assert.AreEqual(1, result38.Count);
            Assert.AreEqual("Output", result38[0].Name);
            List<XmlSchemaElement> result38a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateAppxSymbolPackage", "Output" });
            Assert.AreEqual(0, result38a.Count);

            //GenerateBootstrapper
            Assert.AreEqual("GenerateBootstrapper", result[38].Name);
            List<XmlSchemaElement> result39 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateBootstrapper" });
            Assert.AreEqual(1, result39.Count);
            Assert.AreEqual("Output", result39[0].Name);
            List<XmlSchemaElement> result39a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateBootstrapper", "Output" });
            Assert.AreEqual(0, result39a.Count);

            //GenerateDeploymentManifest
            Assert.AreEqual("GenerateDeploymentManifest", result[39].Name);
            List<XmlSchemaElement> result40 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateDeploymentManifest" });
            Assert.AreEqual(1, result40.Count);
            Assert.AreEqual("Output", result40[0].Name);
            List<XmlSchemaElement> result40a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateDeploymentManifest", "Output" });
            Assert.AreEqual(0, result40a.Count);

            //GeneratePriConfigurationFiles
            Assert.AreEqual("GeneratePriConfigurationFiles", result[40].Name);
            List<XmlSchemaElement> result41 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GeneratePriConfigurationFiles" });
            Assert.AreEqual(1, result41.Count);
            Assert.AreEqual("Output", result41[0].Name);
            List<XmlSchemaElement> result41a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GeneratePriConfigurationFiles", "Output" });
            Assert.AreEqual(0, result41a.Count);

            //GenerateProjectPriFile
            Assert.AreEqual("GenerateProjectPriFile", result[41].Name);
            List<XmlSchemaElement> result42 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateProjectPriFile" });
            Assert.AreEqual(1, result42.Count);
            Assert.AreEqual("Output", result42[0].Name);
            List<XmlSchemaElement> result42a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateProjectPriFile", "Output" });
            Assert.AreEqual(0, result42a.Count);

            //GenerateResource
            Assert.AreEqual("GenerateResource", result[42].Name);
            List<XmlSchemaElement> result43 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateResource" });
            Assert.AreEqual(1, result43.Count);
            Assert.AreEqual("Output", result43[0].Name);
            List<XmlSchemaElement> result43a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateResource", "Output" });
            Assert.AreEqual(0, result43a.Count);

            //GenerateTrustInfo
            Assert.AreEqual("GenerateTrustInfo", result[43].Name);
            List<XmlSchemaElement> result44 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateTrustInfo" });
            Assert.AreEqual(1, result44.Count);
            Assert.AreEqual("Output", result44[0].Name);
            List<XmlSchemaElement> result44a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GenerateTrustInfo", "Output" });
            Assert.AreEqual(0, result44a.Count);

            //GetAssemblyIdentity
            Assert.AreEqual("GetAssemblyIdentity", result[44].Name);
            List<XmlSchemaElement> result45 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetAssemblyIdentity" });
            Assert.AreEqual(1, result45.Count);
            Assert.AreEqual("Output", result45[0].Name);
            List<XmlSchemaElement> result45a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetAssemblyIdentity", "Output" });
            Assert.AreEqual(0, result45a.Count);

            //GetFrameworkPath
            Assert.AreEqual("GetFrameworkPath", result[45].Name);
            List<XmlSchemaElement> result46 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetFrameworkPath" });
            Assert.AreEqual(1, result46.Count);
            Assert.AreEqual("Output", result46[0].Name);
            List<XmlSchemaElement> result46a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetFrameworkPath", "Output" });
            Assert.AreEqual(0, result46a.Count);

            //GetFrameworkSdkPath
            Assert.AreEqual("GetFrameworkSdkPath", result[46].Name);
            List<XmlSchemaElement> result47 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetFrameworkSdkPath" });
            Assert.AreEqual(1, result47.Count);
            Assert.AreEqual("Output", result47[0].Name);
            List<XmlSchemaElement> result47a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetFrameworkSdkPath", "Output" });
            Assert.AreEqual(0, result47a.Count);

            //GetOutputFileName
            Assert.AreEqual("GetOutputFileName", result[47].Name);
            List<XmlSchemaElement> result48 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetOutputFileName" });
            Assert.AreEqual(1, result48.Count);
            Assert.AreEqual("Output", result48[0].Name);
            List<XmlSchemaElement> result48a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetOutputFileName", "Output" });
            Assert.AreEqual(0, result48a.Count);

            //GetReferenceAssemblyPaths
            Assert.AreEqual("GetReferenceAssemblyPaths", result[48].Name);
            List<XmlSchemaElement> result49 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetReferenceAssemblyPaths" });
            Assert.AreEqual(1, result49.Count);
            Assert.AreEqual("Output", result49[0].Name);
            List<XmlSchemaElement> result49a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "GetReferenceAssemblyPaths", "Output" });
            Assert.AreEqual(0, result49a.Count);

            //HarvestWinMDRegistration
            Assert.AreEqual("HarvestWinMDRegistration", result[49].Name);
            List<XmlSchemaElement> result50 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "HarvestWinMDRegistration" });
            Assert.AreEqual(1, result50.Count);
            Assert.AreEqual("Output", result50[0].Name);
            List<XmlSchemaElement> result50a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "HarvestWinMDRegistration", "Output" });
            Assert.AreEqual(0, result50a.Count);

            //IsAssembly
            Assert.AreEqual("IsAssembly", result[50].Name);
            List<XmlSchemaElement> result51 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "IsAssembly" });
            Assert.AreEqual(1, result51.Count);
            Assert.AreEqual("Output", result51[0].Name);
            List<XmlSchemaElement> result51a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "IsAssembly", "Output" });
            Assert.AreEqual(0, result51a.Count);

            //ItemGroup
            Assert.AreEqual("ItemGroup", result[51].Name);
            List<XmlSchemaElement> result52 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ItemGroup" });
            Assert.AreEqual(44, result52.Count);

            //LC
            Assert.AreEqual("LC", result[52].Name);
            List<XmlSchemaElement> result53 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "LC" });
            Assert.AreEqual(1, result53.Count);
            Assert.AreEqual("Output", result53[0].Name);
            List<XmlSchemaElement> result53a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "LC", "Output" });
            Assert.AreEqual(0, result53a.Count);

            //LIB
            Assert.AreEqual("LIB", result[53].Name);
            List<XmlSchemaElement> result54 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "LIB" });
            Assert.AreEqual(1, result54.Count);
            Assert.AreEqual("Output", result54[0].Name);
            List<XmlSchemaElement> result54a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "LIB", "Output" });
            Assert.AreEqual(0, result54a.Count);

            //Link
            Assert.AreEqual("Link", result[54].Name);
            List<XmlSchemaElement> result55 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Link" });
            Assert.AreEqual(1, result55.Count);
            Assert.AreEqual("Output", result55[0].Name);
            List<XmlSchemaElement> result55a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Link", "Output" });
            Assert.AreEqual(0, result55a.Count);

            //MakeDir
            Assert.AreEqual("MakeDir", result[55].Name);
            List<XmlSchemaElement> result56 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MakeDir" });
            Assert.AreEqual(1, result56.Count);
            Assert.AreEqual("Output", result56[0].Name);
            List<XmlSchemaElement> result56a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MakeDir", "Output" });
            Assert.AreEqual(0, result56a.Count);

            //MergePriFiles
            Assert.AreEqual("MergePriFiles", result[56].Name);
            List<XmlSchemaElement> result57 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MergePriFiles" });
            Assert.AreEqual(1, result57.Count);
            Assert.AreEqual("Output", result57[0].Name);
            List<XmlSchemaElement> result57a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MergePriFiles", "Output" });
            Assert.AreEqual(0, result57a.Count);

            //Message
            Assert.AreEqual("Message", result[57].Name);
            List<XmlSchemaElement> result58 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Message" });
            Assert.AreEqual(1, result58.Count);
            Assert.AreEqual("Output", result58[0].Name);
            List<XmlSchemaElement> result58a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Message", "Output" });
            Assert.AreEqual(0, result58a.Count);

            //MIDL
            Assert.AreEqual("MIDL", result[58].Name);
            List<XmlSchemaElement> result59 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MIDL" });
            Assert.AreEqual(1, result59.Count);
            Assert.AreEqual("Output", result59[0].Name);
            List<XmlSchemaElement> result59a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MIDL", "Output" });
            Assert.AreEqual(0, result59a.Count);

            //Move
            Assert.AreEqual("Move", result[59].Name);
            List<XmlSchemaElement> result60 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Move" });
            Assert.AreEqual(1, result60.Count);
            Assert.AreEqual("Output", result60[0].Name);
            List<XmlSchemaElement> result60a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Move", "Output" });
            Assert.AreEqual(0, result60a.Count);

            //MSBuild
            Assert.AreEqual("MSBuild", result[60].Name);
            List<XmlSchemaElement> result61 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MSBuild" });
            Assert.AreEqual(1, result61.Count);
            Assert.AreEqual("Output", result61[0].Name);
            List<XmlSchemaElement> result61a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "MSBuild", "Output" });
            Assert.AreEqual(0, result61a.Count);

            //Mt
            Assert.AreEqual("Mt", result[61].Name);
            List<XmlSchemaElement> result62 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Mt" });
            Assert.AreEqual(1, result62.Count);
            Assert.AreEqual("Output", result62[0].Name);
            List<XmlSchemaElement> result62a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Mt", "Output" });
            Assert.AreEqual(0, result62a.Count);

            //OnError
            Assert.AreEqual("OnError", result[62].Name);
            List<XmlSchemaElement> result63 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "OnError" });
            Assert.AreEqual(0, result63.Count);

            //PropertyGroup
            Assert.AreEqual("PropertyGroup", result[63].Name);
            List<XmlSchemaElement> result64 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "PropertyGroup" });
            Assert.AreEqual(276, result64.Count);

            //RC
            Assert.AreEqual("RC", result[64].Name);
            List<XmlSchemaElement> result65 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RC" });
            Assert.AreEqual(1, result65.Count);
            Assert.AreEqual("Output", result65[0].Name);
            List<XmlSchemaElement> result65a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RC", "Output" });
            Assert.AreEqual(0, result65a.Count);

            //ReadLinesFromFile
            Assert.AreEqual("ReadLinesFromFile", result[65].Name);
            List<XmlSchemaElement> result66 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ReadLinesFromFile" });
            Assert.AreEqual(1, result66.Count);
            Assert.AreEqual("Output", result66[0].Name);
            List<XmlSchemaElement> result66a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ReadLinesFromFile", "Output" });
            Assert.AreEqual(0, result66a.Count);

            //RegisterAssembly
            Assert.AreEqual("RegisterAssembly", result[66].Name);
            List<XmlSchemaElement> result67 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RegisterAssembly" });
            Assert.AreEqual(1, result67.Count);
            Assert.AreEqual("Output", result67[0].Name);
            List<XmlSchemaElement> result67a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RegisterAssembly", "Output" });
            Assert.AreEqual(0, result67a.Count);

            //RemoveDir
            Assert.AreEqual("RemoveDir", result[67].Name);
            List<XmlSchemaElement> result68 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDir" });
            Assert.AreEqual(1, result68.Count);
            Assert.AreEqual("Output", result68[0].Name);
            List<XmlSchemaElement> result68a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDir", "Output" });
            Assert.AreEqual(0, result68a.Count);

            //RemoveDuplicatePayload
            Assert.AreEqual("RemoveDuplicatePayload", result[68].Name);
            List<XmlSchemaElement> result69 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicatePayload" });
            Assert.AreEqual(1, result69.Count);
            Assert.AreEqual("Output", result69[0].Name);
            List<XmlSchemaElement> result69a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicatePayload", "Output" });
            Assert.AreEqual(0, result69a.Count);

            //RemoveDuplicatePriFiles
            Assert.AreEqual("RemoveDuplicatePriFiles", result[69].Name);
            List<XmlSchemaElement> result70 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicatePriFiles" });
            Assert.AreEqual(1, result70.Count);
            Assert.AreEqual("Output", result70[0].Name);
            List<XmlSchemaElement> result70a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicatePriFiles", "Output" });
            Assert.AreEqual(0, result70a.Count);

            //RemoveDuplicates
            Assert.AreEqual("RemoveDuplicates", result[70].Name);
            List<XmlSchemaElement> result71 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicates" });
            Assert.AreEqual(1, result71.Count);
            Assert.AreEqual("Output", result71[0].Name);
            List<XmlSchemaElement> result71a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicates", "Output" });
            Assert.AreEqual(0, result71a.Count);

            //RemoveDuplicateSDKReferences
            Assert.AreEqual("RemoveDuplicateSDKReferences", result[71].Name);
            List<XmlSchemaElement> result72 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicateSDKReferences" });
            Assert.AreEqual(1, result72.Count);
            Assert.AreEqual("Output", result72[0].Name);
            List<XmlSchemaElement> result72a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RemoveDuplicateSDKReferences", "Output" });
            Assert.AreEqual(0, result72a.Count);

            //RequiresFramework35SP1Assembly
            Assert.AreEqual("RequiresFramework35SP1Assembly", result[72].Name);
            List<XmlSchemaElement> result73 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RequiresFramework35SP1Assembly" });
            Assert.AreEqual(1, result73.Count);
            Assert.AreEqual("Output", result73[0].Name);
            List<XmlSchemaElement> result73a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "RequiresFramework35SP1Assembly", "Output" });
            Assert.AreEqual(0, result73a.Count);

            //ResolveAssemblyReference
            Assert.AreEqual("ResolveAssemblyReference", result[73].Name);
            List<XmlSchemaElement> result74 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveAssemblyReference" });
            Assert.AreEqual(1, result74.Count);
            Assert.AreEqual("Output", result74[0].Name);
            List<XmlSchemaElement> result74a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveAssemblyReference", "Output" });
            Assert.AreEqual(0, result74a.Count);

            //ResolveComReference
            Assert.AreEqual("ResolveComReference", result[74].Name);
            List<XmlSchemaElement> result75 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveComReference" });
            Assert.AreEqual(1, result75.Count);
            Assert.AreEqual("Output", result75[0].Name);
            List<XmlSchemaElement> result75a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveComReference", "Output" });
            Assert.AreEqual(0, result75a.Count);

            //ResolveKeySource
            Assert.AreEqual("ResolveKeySource", result[75].Name);
            List<XmlSchemaElement> result76 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveKeySource" });
            Assert.AreEqual(1, result76.Count);
            Assert.AreEqual("Output", result76[0].Name);
            List<XmlSchemaElement> result76a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveKeySource", "Output" });
            Assert.AreEqual(0, result76a.Count);

            //ResolveManifestFiles
            Assert.AreEqual("ResolveManifestFiles", result[76].Name);
            List<XmlSchemaElement> result77 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveManifestFiles" });
            Assert.AreEqual(1, result77.Count);
            Assert.AreEqual("Output", result77[0].Name);
            List<XmlSchemaElement> result77a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveManifestFiles", "Output" });
            Assert.AreEqual(0, result77a.Count);

            //ResolveNativeReference
            Assert.AreEqual("ResolveNativeReference", result[77].Name);
            List<XmlSchemaElement> result78 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveNativeReference" });
            Assert.AreEqual(1, result78.Count);
            Assert.AreEqual("Output", result78[0].Name);
            List<XmlSchemaElement> result78a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveNativeReference", "Output" });
            Assert.AreEqual(0, result78a.Count);

            //ResolveNonMSBuildProjectOutput
            Assert.AreEqual("ResolveNonMSBuildProjectOutput", result[78].Name);
            List<XmlSchemaElement> result79 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveNonMSBuildProjectOutput" });
            Assert.AreEqual(1, result79.Count);
            Assert.AreEqual("Output", result79[0].Name);
            List<XmlSchemaElement> result79a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ResolveNonMSBuildProjectOutput", "Output" });
            Assert.AreEqual(0, result79a.Count);

            //SetEnv
            Assert.AreEqual("SetEnv", result[79].Name);
            List<XmlSchemaElement> result80 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SetEnv" });
            Assert.AreEqual(1, result80.Count);
            Assert.AreEqual("Output", result80[0].Name);
            List<XmlSchemaElement> result80a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SetEnv", "Output" });
            Assert.AreEqual(0, result80a.Count);

            //SGen
            Assert.AreEqual("SGen", result[80].Name);
            List<XmlSchemaElement> result81 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SGen" });
            Assert.AreEqual(1, result81.Count);
            Assert.AreEqual("Output", result81[0].Name);
            List<XmlSchemaElement> result81a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SGen", "Output" });
            Assert.AreEqual(0, result81a.Count);

            //SignAppxPackage
            Assert.AreEqual("SignAppxPackage", result[81].Name);
            List<XmlSchemaElement> result82 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SignAppxPackage" });
            Assert.AreEqual(1, result82.Count);
            Assert.AreEqual("Output", result82[0].Name);
            List<XmlSchemaElement> result82a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SignAppxPackage", "Output" });
            Assert.AreEqual(0, result82a.Count);

            //SignFile
            Assert.AreEqual("SignFile", result[82].Name);
            List<XmlSchemaElement> result83 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SignFile" });
            Assert.AreEqual(1, result83.Count);
            Assert.AreEqual("Output", result83[0].Name);
            List<XmlSchemaElement> result83a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "SignFile", "Output" });
            Assert.AreEqual(0, result83a.Count);

            //StripPrivateSymbols
            Assert.AreEqual("StripPrivateSymbols", result[83].Name);
            List<XmlSchemaElement> result84 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "StripPrivateSymbols" });
            Assert.AreEqual(1, result84.Count);
            Assert.AreEqual("Output", result84[0].Name);
            List<XmlSchemaElement> result84a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "StripPrivateSymbols", "Output" });
            Assert.AreEqual(0, result84a.Count);

            //TlbImp
            Assert.AreEqual("TlbImp", result[84].Name);
            List<XmlSchemaElement> result85 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "TlbImp" });
            Assert.AreEqual(1, result85.Count);
            Assert.AreEqual("Output", result85[0].Name);
            List<XmlSchemaElement> result85a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "TlbImp", "Output" });
            Assert.AreEqual(0, result85a.Count);

            //Touch
            Assert.AreEqual("Touch", result[85].Name);
            List<XmlSchemaElement> result86 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Touch" });
            Assert.AreEqual(1, result86.Count);
            Assert.AreEqual("Output", result86[0].Name);
            List<XmlSchemaElement> result86a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Touch", "Output" });
            Assert.AreEqual(0, result86a.Count);

            //UnregisterAppx
            Assert.AreEqual("UnregisterAppx", result[86].Name);
            List<XmlSchemaElement> result87 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UnregisterAppx" });
            Assert.AreEqual(1, result87.Count);
            Assert.AreEqual("Output", result87[0].Name);
            List<XmlSchemaElement> result87a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UnregisterAppx", "Output" });
            Assert.AreEqual(0, result87a.Count);

            //UnregisterAssembly
            Assert.AreEqual("UnregisterAssembly", result[87].Name);
            List<XmlSchemaElement> result88 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UnregisterAssembly" });
            Assert.AreEqual(1, result88.Count);
            Assert.AreEqual("Output", result88[0].Name);
            List<XmlSchemaElement> result88a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UnregisterAssembly", "Output" });
            Assert.AreEqual(0, result88a.Count);

            //UpdateAppxManifest
            Assert.AreEqual("UpdateAppxManifest", result[88].Name);
            List<XmlSchemaElement> result89 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UpdateAppxManifest" });
            Assert.AreEqual(1, result89.Count);
            Assert.AreEqual("Output", result89[0].Name);
            List<XmlSchemaElement> result89a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UpdateAppxManifest", "Output" });
            Assert.AreEqual(0, result89a.Count);

            //UpdateManifest
            Assert.AreEqual("UpdateManifest", result[89].Name);
            List<XmlSchemaElement> result90 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UpdateManifest" });
            Assert.AreEqual(1, result90.Count);
            Assert.AreEqual("Output", result90[0].Name);
            List<XmlSchemaElement> result90a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "UpdateManifest", "Output" });
            Assert.AreEqual(0, result90a.Count);

            //ValidateAppxManifest
            Assert.AreEqual("ValidateAppxManifest", result[90].Name);
            List<XmlSchemaElement> result91 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ValidateAppxManifest" });
            Assert.AreEqual(1, result91.Count);
            Assert.AreEqual("Output", result91[0].Name);
            List<XmlSchemaElement> result91a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ValidateAppxManifest", "Output" });
            Assert.AreEqual(0, result91a.Count);

            //ValidateAppxManifestItems
            Assert.AreEqual("ValidateAppxManifestItems", result[91].Name);
            List<XmlSchemaElement> result92 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ValidateAppxManifestItems" });
            Assert.AreEqual(1, result92.Count);
            Assert.AreEqual("Output", result92[0].Name);
            List<XmlSchemaElement> result92a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ValidateAppxManifestItems", "Output" });
            Assert.AreEqual(0, result92a.Count);

            //ValidateAppxPackage
            Assert.AreEqual("ValidateAppxPackage", result[92].Name);
            List<XmlSchemaElement> result93 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ValidateAppxPackage" });
            Assert.AreEqual(1, result93.Count);
            Assert.AreEqual("Output", result93[0].Name);
            List<XmlSchemaElement> result93a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "ValidateAppxPackage", "Output" });
            Assert.AreEqual(0, result93a.Count);

            //Vbc
            Assert.AreEqual("Vbc", result[93].Name);
            List<XmlSchemaElement> result94 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Vbc" });
            Assert.AreEqual(1, result94.Count);
            Assert.AreEqual("Output", result94[0].Name);
            List<XmlSchemaElement> result94a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Vbc", "Output" });
            Assert.AreEqual(0, result94a.Count);

            //VCBuild
            Assert.AreEqual("VCBuild", result[94].Name);
            List<XmlSchemaElement> result95 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "VCBuild" });
            Assert.AreEqual(1, result95.Count);
            Assert.AreEqual("Output", result95[0].Name);
            List<XmlSchemaElement> result95a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "VCBuild", "Output" });
            Assert.AreEqual(0, result95a.Count);

            //VCMessage
            Assert.AreEqual("VCMessage", result[95].Name);
            List<XmlSchemaElement> result96 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "VCMessage" });
            Assert.AreEqual(1, result96.Count);
            Assert.AreEqual("Output", result96[0].Name);
            List<XmlSchemaElement> result96a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "VCMessage", "Output" });
            Assert.AreEqual(0, result96a.Count);

            //Warning
            Assert.AreEqual("Warning", result[96].Name);
            List<XmlSchemaElement> result97 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Warning" });
            Assert.AreEqual(1, result97.Count);
            Assert.AreEqual("Output", result97[0].Name);
            List<XmlSchemaElement> result97a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "Warning", "Output" });
            Assert.AreEqual(0, result97a.Count);

            //WriteCodeFragment
            Assert.AreEqual("WriteCodeFragment", result[97].Name);
            List<XmlSchemaElement> result98 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "WriteCodeFragment" });
            Assert.AreEqual(1, result98.Count);
            Assert.AreEqual("Output", result98[0].Name);
            List<XmlSchemaElement> result98a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "WriteCodeFragment", "Output" });
            Assert.AreEqual(0, result98a.Count);

            //WriteLinesToFile
            Assert.AreEqual("WriteLinesToFile", result[98].Name);
            List<XmlSchemaElement> result99 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "WriteLinesToFile" });
            Assert.AreEqual(1, result99.Count);
            Assert.AreEqual("Output", result99[0].Name);
            List<XmlSchemaElement> result99a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "WriteLinesToFile", "Output" });
            Assert.AreEqual(0, result99a.Count);

            //XDCMake
            Assert.AreEqual("XDCMake", result[99].Name);
            List<XmlSchemaElement> result100 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "XDCMake" });
            Assert.AreEqual(1, result100.Count);
            Assert.AreEqual("Output", result100[0].Name);
            List<XmlSchemaElement> result100a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "XDCMake", "Output" });
            Assert.AreEqual(0, result100a.Count);

            //XSD
            Assert.AreEqual("XSD", result[100].Name);
            List<XmlSchemaElement> result101 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "XSD" });
            Assert.AreEqual(1, result101.Count);
            Assert.AreEqual("Output", result101[0].Name);
            List<XmlSchemaElement> result101a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "XSD", "Output" });
            Assert.AreEqual(0, result101a.Count);

            //XslTransformation
            Assert.AreEqual("XslTransformation", result[101].Name);
            List<XmlSchemaElement> result102 = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "XslTransformation" });
            Assert.AreEqual(1, result102.Count);
            Assert.AreEqual("Output", result102[0].Name);
            List<XmlSchemaElement> result102a = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root,
                new string[] { "Project", "Target", "XslTransformation", "Output" });
            Assert.AreEqual(0, result102a.Count);

        }

        #endregion

        #region /Project/UsingTask
        /// <summary>
        /// /Project/UsingTask
        /// </summary>
        [TestMethod]
        public void GetDescendantElementTestMethod225()
        {
            string path = CompletionData.DataManager.GetMSBuildShemaPath();
            XmlSchema schema = CompletionData.DataManager.GetXmlSchema(path);
            XmlSchemaElement root = CompletionData.DataManager.GetRootXmlSchemaElement();
            List<XmlSchemaElement> result = CompletionData.MSBuildXmlSchema.GetDescendantElement(schema, root, new string[] { "Project", "UsingTask" });
            Assert.AreEqual(2, result.Count);
            Assert.AreEqual("ParameterGroup", result[0].Name);
            Assert.AreEqual("Task", result[1].Name);
        }

        #endregion

    }
}
